[Question] Return the query root in a mutation response payload

[rocketraman]

I would like to return the query root in a mutation response payload, as described here: https://graphql-rules.com/rules/mutation-payload-query.

Is there a way to do this? I tried returning the value of DataFetchingEnvironment.getRoot() on a Query type, but that didn't work.

[smyrick]

Hmm, interesting. I have not actually seen this pattern before.

I did a quick update of the example and added this function:

@Component
class SimpleMutation(private val simpleQuery: SimpleQuery) : Mutation {

    fun mutationQueryResponse(input: String): SimpleQuery {
        // Do mutation actions with input
        return simpleQuery
    }
}

SimpleQuery is marked with Query and is a Spring Component. The response type of mutationQueryResponse is SimpleQuery though and not the global Query root object. This is because the schema generator actually handles the creation of the Query object for you and there isn't a single object today that you could create and return to get the entire object.

I wonder though if we could do something like allowing to return com.expediagroup.graphql.server.operations.Query as a return type and that would return the root object for you. I don't know if graphql-java would support this either.

We usually have a specific Mutation response that you want to return so that you can better control what types of data the clients have access to after they do a mutation, but I can see the benefits of this pattern as well

[smyrick]

Doing a quick code dive this would require some pretty big changes to the schema generator and server setup.

• Currently we have no single object in graphql-kotlin-schema-generator that we can use to represent the Query so we may have to move the marker interfaces to the generator.
• If we had the above then we would have to map the usage of the operation back to the internal GraphQLObjectType that is the query, cache it in the SchemaGenerator, and then return that when we saw the new marker as a return type in Mutations only. We couldn't really do a Query in a Query as that would put us in a construction loop.

[smyrick]

I was actually able to throw something together without a breaking change. We actually don't want to use a marker interface as we need to return a created object to satisfy other parts of the generator. So similar to other libraries, you would just return this empty object and not do anything extra

#1170

[rocketraman]

Nice!

[dariuszkuc]

Given a schema

type Query {
  foo: Foo
  bar: Bar
  baz: Bar
}

I am unsure how useful it would be to return whole Query type on mutations.

type Mutation {
  updateFoo: UpdatedFoo
}

type UpdatedFoo {
  result: Boolean
  updated: Query
}

Guess it really depends on your schema but geneally instead of the whole Query object I'd return individual fields that correspond to the target mutation.

Since graphql-kotlin generates schema from source code you could easily return same type for your queries and mutations.

[rocketraman]

Thank you for the detailed response @smyrick . I'm convinced, but I'd still hoping to hear from the authors of that project about their take. Do you mind if I post your response on the issue above?

[smyrick]

Of course, feel free to link to this discussion. I would love to get some other opinions as we don't want to be the sole idea of how a GraphQL schema should be designed, like graphql-rules

[koenpunt]

I think the problem of fetching data in a single request could be solved by sending a batch of queries;

Instead of a single query request, which would look something like this:

{
    "query": "mutation { likePost(id: 1) { record { id title likes } query { lastActivePosts { id title likes } } }"
}

You would send a request with multiple queries;

[
    {
        "query": "mutation { likePost(id: 1) { record { id title likes } }"
    },
    {
        "query": "query { lastActivePosts { id title likes } }"
    }
]

Which I believe should be executed in order, so the second query should retrieve the updated data.

[rocketraman]

I discussed the limitations / problems with the query batching approach above: #1169 (reply in thread).

[rocketraman]

For posterity, a member of graphql-rules replied here: graphql-rules/graphql-rules#61 (comment).

[smyrick]

Update on this, with the addition of @GraphQLType you can now just set the return type to a type reference and this works

@GraphQLType("Query")
fun doSomethingAndGetQuery(): Any {
      return Any()
}

[rocketraman]

Neat @smyrick , that works very nicely. For the record, this can also be set on a property e.g. following the example given at https://graphql-rules.com/rules/mutation-payload-query:

data class LikePostPayload(
  val record: Post,
  @GraphQLType("Query") val query: Any = Any(),
)