Juniper: Vollständige GraphQL-Bibliothek für Rust

Juniper — GraphQL Bibliothek für Rust

Juniper ist eine schnelle, sichere und ergonomische Bibliothek in der Sprache Rust zum Erstellen von GraphQL-Servern. Sie ermöglicht die Entwicklung von APIs mit strenger Typisierung, automatischer Dokumentationsgenerierung und Unterstützung für asynchrone Anfragen. Juniper ist ideal für Projekte, bei denen Leistung, Zuverlässigkeit und Ausdrucksstärke der Typen entscheidend sind.

Im Gegensatz zu traditionellen REST-APIs erlaubt GraphQL dem Client, nur die benötigten Daten anzufragen, was die Netzwerk- und Serverlast reduziert. Juniper implementiert die vollständige GraphQL-Spezifikation (einschließlich Subscriptions über WebSocket), was es zu einer hervorragenden Wahl für moderne Webanwendungen in Rust macht.

Hauptfunktionen

• Vollständige GraphQL-Unterstützung — Queries, Mutationen, Subscriptions.
• Asynchronität — funktioniert von Haus aus mit async/await (über futures).
• Integration mit gängigen Frameworks — Actix-web, Rocket, Warp, Tide, Axum.
• Automatische Schema-Generierung — basierend auf Rust-Strukturen.
• Kontextunterstützung — Übergabe von Zustand (DB, Authentifizierung) an Resolver.
• Erweiterbarkeit — benutzerdefinierte Skalare, Direktiven, Schnittstellen.
• Sicherheit — strenge Typisierung auf Kompilierungsebene, verhindert Laufzeitfehler.
• Dokumentation — automatische Generierung des GraphQL-Schemas (SDL).

Installation

Fügen Sie juniper zu Ihrer Cargo.toml hinzu:

[dependencies]juniper = "0.16"

Für die Integration mit einem Webframework fügen Sie die entsprechende Crate hinzu. Zum Beispiel für Actix-web:

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

Erstellen eines einfachen GraphQL-Servers

Betrachten wir ein Beispiel zum Erstellen einer API zum Abrufen einer Benutzerliste. Zuerst definieren wir das Datenmodell und die Resolver.

1. Definition der GraphQL-Typen

Verwenden Sie die Makros #[derive(GraphQLObject)] und #[derive(GraphQLInputObject)]:

use juniper::{GraphQLObject, GraphQLInputObject};

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

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

2. Erstellen des Kontexts und der Root-Queries

Der Kontext enthält normalerweise den Zugriff auf die Datenbank oder andere Dienste:

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

// Kontext für Resolverpub struct Context {    pub db: Database,}

// Implementierung des Context-Traits für Juniperimpl juniper::Context for Context {}

3. Definition der Root-Query und 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