Juniper : Bibliothèque GraphQL complète pour Rust

Juniper — Bibliothèque GraphQL pour Rust

Juniper est une bibliothèque rapide, sûre et ergonomique en langage Rust pour construire des serveurs GraphQL. Elle permet de développer des API avec un typage strict, une génération automatique de documentation et la prise en charge des requêtes asynchrones. Juniper est idéale pour les projets où la performance, la fiabilité et l'expressivité des types sont critiques.

Contrairement aux API REST traditionnelles, GraphQL permet au client de demander uniquement les données nécessaires, ce qui réduit la charge sur le réseau et le serveur. Juniper implémente la spécification complète de GraphQL (y compris les abonnements via WebSocket), ce qui en fait un excellent choix pour les applications web modernes en Rust.

Fonctionnalités principales

• Prise en charge complète de GraphQL — requêtes, mutations, abonnements.
• Asynchrone — fonctionne nativement avec async/await (via futures).
• Intégration avec les frameworks populaires — Actix-web, Rocket, Warp, Tide, Axum.
• Génération automatique de schéma — basée sur les structures Rust.
• Prise en charge du contexte — transmission de l'état (BDD, authentification) aux résolveurs.
• Extensibilité — scalaires personnalisés, directives, interfaces.
• Sécurité — typage strict au niveau de la compilation, prévient les erreurs d'exécution.
• Documentation — génération automatique du schéma GraphQL (SDL).

Installation

Ajoutez juniper dans le fichier Cargo.toml de votre projet :

[dependencies]juniper = "0.16"

Pour l'intégration avec un framework web, ajoutez la crate correspondante. Par exemple, pour Actix-web :

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

Création d'un serveur GraphQL simple

Examinons un exemple de création d'API pour obtenir une liste d'utilisateurs. Commençons par définir le modèle de données et les résolveurs.

1. Définition des types GraphQL

Utilisez les macros #[derive(GraphQLObject)] et #[derive(GraphQLInputObject)] :

use juniper::{GraphQLObject, GraphQLInputObject};

#[derive(GraphQLObject)]#[graphql(description = "Utilisateur du système")]struct User {    id: i32,    name: String,    email: String,}

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

2. Création du contexte et des requêtes racines

Le contexte contient généralement l'accès à la base de données ou à d'autres services :

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() },            ]),        }    }}

// Contexte pour les résolveurspub struct Context {    pub db: Database,}

// Implémentation du trait Context pour Juniperimpl juniper::Context for Context {}

3. Définition de la requête racine (Query) et de la mutation (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