API GraphQL avec Kotlin : tutoriel pratique étape par étape

Introduction : Pourquoi GraphQL et Kotlin forment-ils le duo idéal ?

Dans le développement web moderne, le choix du bon outil pour créer une API détermine la vitesse de développement et la facilité de maintenance. GraphQL est un langage de requêtes qui permet aux clients de demander uniquement les données dont ils ont besoin, éliminant ainsi les problèmes de sur-récupération et de sous-récupération propres à REST. Kotlin, quant à lui, est un langage moderne, concis et sûr, parfaitement adapté au développement backend, notamment en combinaison avec Spring Boot.

Dans ce tutoriel, nous allons créer en pratique une API GraphQL complète avec Kotlin. Vous apprendrez à configurer le serveur, définir le schéma, implémenter des requêtes et des mutations, et tester l'API finale. À la fin de l'article, vous disposerez d'un projet fonctionnel pouvant servir de base pour vos propres applications.

1. Configuration du projet et des dépendances

Nous allons d'abord créer un nouveau projet Spring Boot avec le support de GraphQL. Nous utiliserons Spring for GraphQL — l'intégration officielle qui rend le travail extrêmement simple.

1.1. Création du projet

Vous pouvez utiliser Spring Initializr ou n'importe quel IDE (IntelliJ IDEA). Ajoutez les dépendances suivantes :

• Spring Web
• Spring for GraphQL
• Spring Data JPA
• Base de données H2 (pour simplifier)

Dans le fichier build.gradle.kts, vous devez avoir les lignes suivantes :

dependencies {    implementation("org.springframework.boot:spring-boot-starter-web")    implementation("org.springframework.boot:spring-boot-starter-graphql")    implementation("org.springframework.boot:spring-boot-starter-data-jpa")    runtimeOnly("com.h2database:h2")    testImplementation("org.springframework.boot:spring-boot-starter-test")}

1.2. Configuration

Créons une entité simple Book et un repository pour interagir avec la base de données.

// Book.kt@Entitydata class Book(    @Id @GeneratedValue(strategy = GenerationType.IDENTITY)    val id: Long = 0,    val title: String,    val author: String,    val year: Int)

// BookRepository.ktinterface BookRepository : JpaRepository<Book, Long>

2. Création du schéma GraphQL et du contrôleur

GraphQL utilise un typage strict. Le schéma définit les données disponibles et la manière de les interroger. Dans Spring for GraphQL, le schéma peut être décrit à l'aide d'annotations.

2.1. Définition du schéma via le code

Créons une classe contrôleur qui gérera les requêtes GraphQL. Utilisons l'annotation @QueryMapping pour la lecture des données et @MutationMapping pour les modifications.

// BookController.kt@Controllerclass BookController(private val repository: BookRepository) {

    @QueryMapping    fun allBooks(): List<Book> = repository.findAll()

    @QueryMapping    fun bookById(@Argument id: Long): Book? = repository.findById(id).orElse(null)

    @MutationMapping    fun addBook(@Argument title: String, @Argument author: String, @Argument year: Int): Book {        val book = Book(title = title, author = author, year = year)        return repository.save(book)    }

    @MutationMapping    fun deleteBook(@Argument id: Long): Boolean {        if (repository.existsById(id)) {            repository.deleteById(id)            return true        }        return false    }}

2.2. Alternative : fichier de schéma .graphqls

Vous pouvez également définir le schéma dans un fichier séparé schema.graphqls dans le dossier resources/graphql :

type Query {    allBooks: [Book]    bookById(id: ID!): Book}

type Mutation {    addBook(title: String!, author: String!, year: Int!): Book    deleteBook(id: ID!): Boolean}

type Book {    id: ID!    title: S