GraphQL API com Rust: tutorial passo a passo para criar um serviço web

API GraphQL com Rust: tutorial passo a passo

GraphQL é uma linguagem de consulta para APIs que permite que os clientes obtenham apenas os dados necessários. Rust, por sua vez, é conhecido por seu desempenho e segurança de memória. Neste tutorial, criaremos uma API GraphQL completa em Rust usando as bibliotecas Juniper e Actix-web. Você aprenderá como configurar o servidor, definir o esquema, implementar consultas e mutações, além de testar a API.

Este material será útil para desenvolvedores familiarizados com os fundamentos de Rust e desenvolvimento web. Vamos nos concentrar na implementação prática, evitando teoria excessiva.

Configuração do projeto e instalação de dependências

Primeiro, vamos criar um novo projeto Rust:

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

Adicionaremos as dependências necessárias ao arquivo Cargo.toml:

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

Aqui, actix-web é o framework web, e juniper é a biblioteca para trabalhar com GraphQL. juniper_actix fornece a integração entre eles.

Criação do esquema básico do GraphQL

Agora, vamos definir um modelo de dados simples e um esquema. Como exemplo, criaremos um sistema de gerenciamento de usuários e postagens.

Crie o arquivo src/schema.rs:

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

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

#[derive(GraphQLInputObject)]#[graphql(description = "Dados de entrada para criar um usuário")]pub struct NewUser {    pub name: String,    pub email: String,}

#[derive(GraphQLObject)]#[graphql(description = "Postagem do usuário")]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: "Primeira postagem".into(), body: "Texto do 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>;

Definimos dois objetos raiz: QueryRoot para consultas (obter dados) e MutationRoot para mutações (alterar dados). #[derive(GraphQLObject)] gera automaticamente os tipos GraphQL a partir das estruturas Rust.

Configuração do servidor web e integração com Actix-web

Agora, vamos criar o arquivo principal src/main.rs para iniciar o 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
```