Actix-web

use actix_web::{get, post, web, App, HttpResponse, HttpServer, Responder};
use serde::Deserialize;
 
#[derive(Deserialize)]
struct CreateItem { name: String }
 
#[get("/health")]
async fn health() -> impl Responder { "ok" }
 
#[post("/items")]
async fn create(body: web::Json<CreateItem>) -> HttpResponse {
    HttpResponse::Created().json(serde_json::json!({ "name": body.name }))
}
 
#[actix_web::main]
async fn main() -> std::io::Result<()> {
    HttpServer::new(|| App::new().service(health).service(create))
        .bind(("127.0.0.1", 8080))?
        .run()
        .await
}

use actix_web::{delete, get, post, web, App, HttpResponse, HttpServer};
use serde::{Deserialize, Serialize};
use std::sync::Mutex;
 
#[derive(Serialize, Clone)]
struct Item { id: u64, name: String }
 
#[derive(Deserialize)]
struct NewItem { name: String }
 
struct AppState { items: Mutex<Vec<Item>> }
 
#[get("/items")]
async fn list(data: web::Data<AppState>) -> web::Json<Vec<Item>> {
    web::Json(data.items.lock().unwrap().clone())
}
 
#[post("/items")]
async fn create(data: web::Data<AppState>, body: web::Json<NewItem>) -> HttpResponse {
    let mut items = data.items.lock().unwrap();
    let item = Item { id: items.len() as u64 + 1, name: body.name.clone() };
    items.push(item.clone());
    HttpResponse::Created().json(item)
}
 
#[delete("/items/{id}")]
async fn remove(data: web::Data<AppState>, path: web::Path<u64>) -> HttpResponse {
    let mut items = data.items.lock().unwrap();
    if let Some(pos) = items.iter().position(|i| i.id == *path) {
        items.remove(pos);
        HttpResponse::NoContent().finish()
    } else {
        HttpResponse::NotFound().finish()
    }
}
 
#[actix_web::main]
async fn main() -> std::io::Result<()> {
    let state = web::Data::new(AppState { items: Mutex::new(vec![]) });
    HttpServer::new(move || {
        App::new()
            .app_data(state.clone())
            .service(list)
            .service(create)
            .service(remove)
    })
    .bind(("127.0.0.1", 8080))?
    .run()
    .await
}

// Escopo de rotas sob um prefixo
use actix_web::web::scope;
App::new().service(scope("/api/v1").service(list).service(create));