GraphQL API con Rust: tutorial paso a paso para crear un servicio web

API GraphQL con Rust: tutorial paso a paso

GraphQL es un lenguaje de consulta para API que permite a los clientes obtener solo los datos necesarios. Rust, por su parte, es conocido por su rendimiento y seguridad de memoria. En este tutorial crearemos una API GraphQL completa en Rust utilizando las bibliotecas Juniper y Actix-web. Aprenderá cómo configurar el servidor, definir el esquema, implementar consultas y mutaciones, así como probar la API.

Este material será útil para desarrolladores familiarizados con los fundamentos de Rust y el desarrollo web. Nos centraremos en la implementación práctica, evitando teoría innecesaria.

Configuración del proyecto e instalación de dependencias

Primero crearemos un nuevo proyecto Rust:

cargo new rust-graphql-apicd rust-graphql-api

Agreguemos las dependencias necesarias en el archivo Cargo.toml:

[dependencies]actix-web = "4"actix-rt = "2"serde = { version = "1", features = ["derive"] }serde_json = "1"juniper = "0.16"juniper_actix = "2"

Aquí actix-web es el framework web, y juniper es la biblioteca para trabajar con GraphQL. juniper_actix proporciona la integración entre ellos.

Creación del esquema GraphQL básico

Ahora definamos un modelo de datos y un esquema simples. Como ejemplo, crearemos un sistema de gestión de usuarios y publicaciones.

Creemos el archivo src/schema.rs:

use juniper::{GraphQLObject, GraphQLInputObject, RootNode};

#[derive(GraphQLObject)]#[graphql(description = "Usuario del sistema")]pub struct User {    pub id: i32,    pub name: String,    pub email: String,}

#[derive(GraphQLInputObject)]#[graphql(description = "Datos de entrada para crear un usuario")]pub struct NewUser {    pub name: String,    pub email: String,}

#[derive(GraphQLObject)]#[graphql(description = "Publicación del usuario")]pub struct Post {    pub id: i32,    pub title: String,    pub body: String,    pub author_id: i32,}

pub struct QueryRoot;

#[juniper::object]impl QueryRoot {    fn users() -> Vec<User> {        vec![            User { id: 1, name: "Alexey".into(), email: "alex@example.com".into() },            User { id: 2, name: "Maria".into(), email: "maria@example.com".into() },        ]    }

    fn posts() -> Vec<Post> {        vec![            Post { id: 1, title: "Primera entrada".into(), body: "Texto del post".into(), author_id: 1 },        ]    }}

pub struct MutationRoot;

#[juniper::object]impl MutationRoot {    fn create_user(new_user: NewUser) -> User {        User {            id: 3,            name: new_user.name,            email: new_user.email,        }    }}

pub type Schema = RootNode<'static, QueryRoot, MutationRoot>;

Hemos definido dos objetos raíz: QueryRoot para consultas (obtención de datos) y MutationRoot para mutaciones (modificación de datos). #[derive(GraphQLObject)] genera automáticamente tipos GraphQL a partir de las estructuras Rust.

Configuración del servidor web e integración con Actix-web

Ahora creemos el archivo principal src/main.rs para iniciar el servidor:

mod schema;

use actix_web::{web, App, HttpServer, HttpResponse, middleware};use juniper_actix::{graphql_handler, playground_handler};use std::sync::Arc;

use crate::schema::Schema;

async fn graphql_route(    req: actix_web::HttpRequest,    payload: actix_web::web::Payload,    schema: web::Data<Arc<Schema>>,) -> actix_web::Result<HttpResponse> {    let context = ();    graphql_handler(&schema, &context, req, payload).await}

async fn playground_route() -> actix_web::Result<HttpResponse> {    playground_handler("/graphql", None).await}

#[actix_web::main]async fn main() -> std::io::Result<()> {    let