API GraphQL con Kotlin: tutorial práctico paso a paso

Introducción: ¿Por qué GraphQL y Kotlin son la pareja ideal?

En el desarrollo web moderno, elegir la herramienta adecuada para crear APIs determina la velocidad de desarrollo y la facilidad de mantenimiento. GraphQL es un lenguaje de consulta que permite a los clientes solicitar solo los datos que necesitan, eliminando el problema de over-fetching y under-fetching propio de REST. Kotlin, por su parte, es un lenguaje moderno, conciso y seguro, ideal para el desarrollo backend, especialmente en combinación con Spring Boot.

En este tutorial, crearemos en la práctica una API GraphQL completa en Kotlin. Aprenderás a configurar el servidor, definir el esquema, implementar consultas y mutaciones, y probar la API terminada. Al final del artículo, tendrás un proyecto funcional que podrás usar como base para tus propias aplicaciones.

1. Configuración del proyecto y dependencias

Lo primero es crear un nuevo proyecto Spring Boot con soporte para GraphQL. Usaremos Spring for GraphQL, la integración oficial que simplifica al máximo el trabajo.

1.1. Creación del proyecto

Puedes usar Spring Initializr o cualquier IDE (IntelliJ IDEA). Añade las siguientes dependencias:

• Spring Web
• Spring for GraphQL
• Spring Data JPA
• H2 Database (para simplificar)

En el archivo build.gradle.kts deben estar las siguientes líneas:

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. Configuración

Crearemos una entidad simple Book y un repositorio para trabajar con la base de datos.

// 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. Creación del esquema GraphQL y del controlador

GraphQL utiliza tipado estricto. El esquema define qué datos están disponibles y cómo se pueden consultar. En Spring for GraphQL, el esquema se puede describir mediante anotaciones.

2.1. Definición del esquema mediante código

Crearemos una clase controladora que manejará las consultas GraphQL. Usamos la anotación @QueryMapping para leer datos y @MutationMapping para modificaciones.

// 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. Alternativa: archivo de esquema .graphqls

También puedes definir el esquema en un archivo separado schema.graphqls dentro de la carpeta 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