Should I make my Mutations and Queries @Transactional

[RIP21]

Hi, I have a question.
Should I make my Mutations and Queries @transactional when they are not wiring any Spring Data repositories and only call services that are calling them and are @transactional.

I'm using Hibernate + Spring Data and I want to be sure that if one of my resolvers already queried something and then another resolver queries the exact same thing, then it will be resolved instantly without query to DB so will be using Hibernate Session L1 Cache.

Unsure how GraphQL Kotlin is interoperable with Spring Data. As with regular REST, it's is pretty simple, you have an entry point which is just some controller and this is where you open the session, then the rest just goes deeper calling functions and services until it's all done and returned back to the client. With GraphQL I'm unsure whether the session will be per resolver then, or per whole query so will be opened and reused for all resolvers and their services that they're calling.

If I'll be able to utilize the same Hibernate session through the whole query then it will optimize my GraphQL API a lot and dataloader pattern will be needed solely for Batch fetching by IDs only and the rest will be just effective by default.

Thanks!

[dariuszkuc]

Hello 👋

With traditional servlet based REST APIs you work with endpoints that provide you complete responses and also have access to request level scope that helps to manage your transactions. Once you move to the reactive Webflux based APIs (which we use in graphql-kotlin-spring-server), AFAIK those annotations won't work and you will have to programmatically manage your transactions.

GraphQL is slightly different that you requests are always processed through the single /graphql endpoint that parses the requests and resolves each field independently of each other. Since single GraphQL request can span multiple queries or mutations, creating transactions per query/mutation may not be what you are looking for (although if you have multiple mutations that have to run in single transaction I'd highly recommend to revisit your data model, see https://graphqlme.com/2018/05/13/transactions-mutations-and-graphql/).

In order to have transactions spanning your whole request I think you probably would need to explicitly start the transaction before executing GraphQL engine. We recently abstracted away the generic server logic so you could easily implement your own GraphQLServer (https://expediagroup.github.io/graphql-kotlin/docs/server/graphql-server) that does that. There are few gotchas there though as, GraphQL does allow partial responses so you would not only need to account for complete failures (e.g. attempting to return null for non-nullable field) but also potentially inspect the response to see whether there are any errors there that should trigger rollback. Furthermore you would need to have a way to ensure all your DAOs use the same transaction. Personally I'd try to keep it simple and contain the transactional logic to a single query and/or service at a time.

[RIP21]

So, exactly what I thought. Thank you for this very detailed answer that removes any possible follow up questions :D
BTW adding such thing to docs of Spring server section would be awesome :) So people know how to deal with it.

BTW nice that you added new pieces to the docs related to DataLoaders and Server configuration overall.

[RIP21]

@dariuszkuc
Am I right that I can just override this bean
https://github.com/ExpediaGroup/graphql-kotlin/blob/master/servers/graphql-kotlin-spring-server/src/main/kotlin/com/expediagroup/graphql/server/spring/GraphQLRoutesConfiguration.kt
graphQLRoutes()
With exactly the same code, and just mark it as @transactional and it will probably work just fine?
Or maybe to create a regular @controller and autowire GraphQLServer and, again mark controller as @transactional and run graphqlServer.execute the same way as in the code above and it should work as intended?

I guess it's the question many would like to have answered :D So some working example would be nice :)

[dariuszkuc]

AFAIK @Transactional does not work with Spring Webflux (which is used in graphql-kotlin-spring-server). You should use Spring Data R2DBC and programmatically start the transactions directly in GraphQLServer. Instead of doing per request transaction, I personally would try to move the transaction management directly to a target resolver (i.e. within a function) and wouldn't bother with trying to make it work across multiple resolvers (as suggested in the linked article above).