GraphQL mutation implementation in Spring Boot using #GraphQlRepository - spring-boot

Question

I have the following Spring Boot reactive "stack" with GraphQL and MongoDB (in Kotlin):
spring-boot-starter-webflux
spring-boot-starter-graphql
spring-boot-starter-data-mongodb-reactive
A very basic example for a server which exposes a GraphQL API to query customers:
import org.springframework.boot.autoconfigure.SpringBootApplication
import org.springframework.boot.runApplication
import org.springframework.data.annotation.Id
import org.springframework.data.mongodb.core.mapping.Document
import org.springframework.data.mongodb.repository.ReactiveMongoRepository
import org.springframework.graphql.data.GraphQlRepository
#SpringBootApplication class ServerApplication
fun main(args: Array<String>) {
runApplication<ServerApplication>(*args)
}
#Document
data class Customer(
#Id val id: String? = null,
val name: String?,
)
#GraphQlRepository
interface CustomerRepository : ReactiveMongoRepository<Customer, String>
In combination with the following GraphQL schema file
type Customer {
id: ID
name: String
}
type Query {
customers: [Customer]
customerById(id: ID!): Customer
}
type Mutation {
createCustomer(name: String!): Customer
}
It is already possible to query customers / customerById and retrieve the data accordingly using e.g.:
{
customers { id name }
customerById(id: "...") { name }
}
This is made possible by the #GraphQlRepository annotation, which automatically registers a handler for fetching data directly from the database.
However, I can't find anything in the documentation about how mutations are implemented i.e. if there is such a simple automatic solution like for the queries or if this has to be implemented manually by a controller with #MutationMapping.
#Controller
class CustomerController(val customerRepository: CustomerRepository) {
#MutationMapping
fun createCustomer(#Argument name: String?): Mono<Customer> {
return customerRepository.save(Customer(name = name))
}
}

Answer 1

As far as I know, mutations must be implemented through a dedicated, #MutationMapping annotated method in the Controller like you suggest. I have made a couple of exercises and the only difference from your example is that I have used a special Input type -both in the schema and in the Java codebase- to define it; in your case, a String will do.
The schema:
type Query{
obras: [Obra]
obrasPorArtista(apellidoArtista:String!): [Obra]
}
type Mutation{
addObra(nueva: ObraInput): Obra
}
type Obra{
id: ID
titulo: String
precio: Float
}
input ObraInput{
titulo: String
artista: String
precio: Float
}
The Controller (the service is injected):
#MutationMapping
public Mono<Obra> addObra(#Argument ObraInput nueva){
return obraService.guardarObra(nueva);
}
The ObraInput:
public record ObraInput(String titulo, String artista, double precio) {}
(The Obra is an Entity with the JPA annotations, columns, etc)
Hope it helps!