Juniper : Une bibliothèque GraphQL élégante en Rust pour les applications web modernes

Juniper — GraphQL en Rust avec sécurité des types et performances

Dans le monde des API web modernes, GraphQL est devenu une norme pour construire des interfaces flexibles et efficaces. Si vous développez en Rust et cherchez une bibliothèque mature, sûre et rapide pour implémenter GraphQL, alors Juniper est ce qu'il vous faut. Juniper propose une approche déclarative basée sur les macros, un support complet des types Rust et une intégration transparente avec les frameworks web populaires.

Juniper permet de décrire le schéma GraphQL directement via les structures et énumérations Rust, garantissant ainsi la sécurité des types (type-safety) à toutes les étapes. La bibliothèque prend en charge les souscriptions (subscriptions), les mutations (mutations), les types complexes, les interfaces, les types union et les scalaires personnalisés. Grâce aux abstractions à coût zéro de Rust, Juniper fonctionne avec une surcharge minimale.

Fonctionnalités principales de Juniper

• Description déclarative du schéma — utilisez les macros #[derive(GraphQLObject)], #[derive(GraphQLInputObject)] et #[derive(GraphQLEnum)].
• Support de l'asynchrone — fonctionne avec async/await et tout runtime asynchrone (Tokio, async-std).
• Contextes intégrés — transmettez l'état (base de données, autorisation) via Context.
• Souscriptions (Subscriptions) — implémentation de mises à jour en temps réel via WebSocket.
• Intégration avec les frameworks — crates officiels pour actix-web, rocket, warp, axum et iron.
• Validation et erreurs — vérification automatique des types et erreurs personnalisées via FieldError.

Démarrage rapide avec Juniper et Actix-web

Examinons un exemple minimal de serveur GraphQL avec Actix-web. Pour commencer, ajoutez les dépendances dans Cargo.toml :

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

Créons maintenant un schéma simple avec une requête racine :

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

// Définition de l'objet de réponse#[derive(GraphQLObject)]struct User {    id: i32,    name: String,    email: String,}

// Objet d'entrée pour la mutation#[derive(GraphQLInputObject)]struct CreateUserInput {    name: String,    email: String,}

// Contexte — stockage de données (par exemple, en mémoire)pub struct Database {    users: Vec<User>,}

impl Context for Database {}

// Requêtes racines (Query)pub struct Query;

#[juniper::graphql_object(context = Database)]impl Query {    fn users(context: &Database) -> Vec<User> {        context.users.clone()    }

    fn user(context: &Database, id: i32) -> Option<User> {        context.users.iter().find(|u| u.id == id).cloned()    }}

// Mutations racines (Mutation)pub struct Mutation;

#[juniper::graphql_object(context = Database)]impl Mutation {    fn create_user(context: &mut Database, input: CreateUserInput) -> FieldResult<User> {        let new_id = context.users.len() as i32 + 1;        let user = User {            id: new_id,            name: input.name,            email: input.email,        };        context.users.push(user.clone());        Ok(user)    }}

// Assemblage du schémapub type Schema = RootNode<'static, Query, Mutation>;

Intégration avec Actix-web

Connectons maintenant Juniper aux points de terminaison HTTP d'Actix-web :

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