Juniper: Biblioteca GraphQL completa para Rust

Juniper — Biblioteca GraphQL para Rust

Juniper es una biblioteca rápida, segura y ergonómica en el lenguaje Rust para construir servidores GraphQL. Permite desarrollar API con tipado estricto, generación automática de documentación y soporte para consultas asíncronas. Juniper es ideal para proyectos donde el rendimiento, la confiabilidad y la expresividad de los tipos son críticos.

A diferencia de las API REST tradicionales, GraphQL permite al cliente solicitar solo los datos necesarios, lo que reduce la carga en la red y el servidor. Juniper implementa la especificación completa de GraphQL (incluyendo suscripciones a través de WebSocket), lo que la convierte en una excelente opción para aplicaciones web modernas en Rust.

Características principales

• Soporte completo de GraphQL — consultas, mutaciones, suscripciones.
• Asincronía — funciona de serie con async/await (a través de futures).
• Integración con frameworks populares — Actix-web, Rocket, Warp, Tide, Axum.
• Generación automática de esquemas — basada en estructuras de Rust.
• Soporte de contexto — transmisión de estado (BD, autenticación) a los resolutores.
• Extensibilidad — escalares personalizados, directivas, interfaces.
• Seguridad — tipado estricto a nivel de compilación, previene errores en tiempo de ejecución.
• Documentación — generación automática del Schema GraphQL (SDL).

Instalación

Añada juniper en Cargo.toml de su proyecto:

[dependencies]juniper = "0.16"

Para la integración con un framework web, añada el crate correspondiente. Por ejemplo, para Actix-web:

[dependencies]juniper = "0.16"actix-web = "4"juniper_actix = "0.3"

Creación de un servidor GraphQL simple

Veamos un ejemplo de creación de una API para obtener una lista de usuarios. Primero, definamos el modelo de datos y los resolutores.

1. Definición de tipos GraphQL

Usamos las macros #[derive(GraphQLObject)] y #[derive(GraphQLInputObject)]:

use juniper::{GraphQLObject, GraphQLInputObject};

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

#[derive(GraphQLInputObject)]#[graphql(description = "Nuevo usuario")]struct NewUser {    name: String,    email: String,}

2. Creación del contexto y consultas raíz

El contexto normalmente contiene acceso a la base de datos u otros servicios:

use std::sync::Mutex;

struct Database {    users: Mutex<Vec<User>>,}

impl Database {    fn new() -> Self {        Database {            users: Mutex::new(vec![                User { id: 1, name: "Alice".into(), email: "alice@example.com".into() },                User { id: 2, name: "Bob".into(), email: "bob@example.com".into() },            ]),        }    }}

// Contexto para los resolutorespub struct Context {    pub db: Database,}

// Implementación del trait Context para Juniperimpl juniper::Context for Context {}

3. Definición de la consulta raíz (Query) y la mutación (Mutation)

pub struct QueryRoot;

#[juniper::graphql_object(Context = Context)]impl QueryRoot {    fn users(context: &Context) -> Vec<User> {        let db = context.db.users.lock().unwrap();        db.clone()    }

    fn user(context: &Context, id: i32) -> Option<User> {        let db = context.db.users.lock().unwrap();        db.iter().find(|u| u.id == id).cloned()    }}

pub struct MutationRoot;

#[juniper::graphql_object(Context = Context)]impl MutationRoot {    fn create_user(context: &Context, new_user: NewUser) -> U