Une API web en Rust avec axum, comparée à Express

cargo new parc-api
cd parc-api
cargo add axum
cargo add tokio --features full
cargo add serde --features derive

[dependencies]
axum = "0.8.9"
serde = { version = "1.0.229", features = ["derive"] }
tokio = { version = "1.54.1", features = ["full"] }

use std::sync::{Arc, Mutex};

use axum::{
    Json, Router,
    extract::{Path, Query, State},
    http::StatusCode,
    routing::get,
};
use serde::{Deserialize, Serialize};

#[derive(Clone, Copy, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "lowercase")]
enum TypePoste {
    Fixe,
    Portable,
    Serveur,
}

#[derive(Clone, Serialize, Deserialize)]
struct Poste {
    numero: String,
    type_poste: TypePoste,
    marque: String,
    prix_ht: u32,
    annee_achat: i32,
}

/// Les postes, partagés entre toutes les requêtes.
type Parc = Arc<Mutex<Vec<Poste>>>;

/// Les paramètres de `GET /postes?type=portable`.
#[derive(Deserialize)]
struct Filtre {
    #[serde(rename = "type")]
    type_poste: Option<TypePoste>,
}

async fn lister(State(parc): State<Parc>, Query(filtre): Query<Filtre>) -> Json<Vec<Poste>> {
    let postes = parc.lock().unwrap();
    let resultat = postes
        .iter()
        .filter(|p| filtre.type_poste.is_none_or(|t| p.type_poste == t))
        .cloned()
        .collect();
    Json(resultat)
}

async fn detail(
    State(parc): State<Parc>,
    Path(numero): Path<String>,
) -> Result<Json<Poste>, StatusCode> {
    let postes = parc.lock().unwrap();
    postes
        .iter()
        .find(|p| p.numero == numero)
        .cloned()
        .map(Json)
        .ok_or(StatusCode::NOT_FOUND)
}

async fn creer(
    State(parc): State<Parc>,
    Json(poste): Json<Poste>,
) -> Result<(StatusCode, Json<Poste>), StatusCode> {
    let mut postes = parc.lock().unwrap();
    if postes.iter().any(|p| p.numero == poste.numero) {
        return Err(StatusCode::CONFLICT);
    }
    postes.push(poste.clone());
    Ok((StatusCode::CREATED, Json(poste)))
}

#[tokio::main]
async fn main() {
    let parc: Parc = Arc::new(Mutex::new(vec![
        Poste {
            numero: "PC-0001".to_string(),
            type_poste: TypePoste::Portable,
            marque: "Dell".to_string(),
            prix_ht: 89900,
            annee_achat: 2023,
        },
        Poste {
            numero: "PC-0002".to_string(),
            type_poste: TypePoste::Fixe,
            marque: "HP".to_string(),
            prix_ht: 64900,
            annee_achat: 2020,
        },
    ]));

    let app = Router::new()
        .route("/postes", get(lister).post(creer))
        .route("/postes/{numero}", get(detail))
        .with_state(parc);

    let ecouteur = tokio::net::TcpListener::bind("127.0.0.1:3000").await.unwrap();
    println!("API du parc sur http://127.0.0.1:3000");
    axum::serve(ecouteur, app).await.unwrap();
}

curl -i http://127.0.0.1:3000/postes/PC-0002

HTTP/1.1 200 OK
content-type: application/json
content-length: 89

{"numero":"PC-0002","type_poste":"fixe","marque":"HP","prix_ht":64900,"annee_achat":2020}

curl -i -X POST http://127.0.0.1:3000/postes \
  -H 'Content-Type: application/json' \
  -d '{"numero":"PC-0003","type_poste":"portable","marque":"Lenovo","prix_ht":104900,"annee_achat":2024}'

import express from 'express';

const TYPES = ['fixe', 'portable', 'serveur'];
const postes = [
  { numero: 'PC-0001', type_poste: 'portable', marque: 'Dell', prix_ht: 89900, annee_achat: 2023 },
  { numero: 'PC-0002', type_poste: 'fixe', marque: 'HP', prix_ht: 64900, annee_achat: 2020 },
];

const app = express();
app.use(express.json());

app.get('/postes', (req, res) => {
  const { type } = req.query;
  res.json(type ? postes.filter((p) => p.type_poste === type) : postes);
});

app.get('/postes/:numero', (req, res) => {
  const poste = postes.find((p) => p.numero === req.params.numero);
  if (!poste) return res.sendStatus(404);
  res.json(poste);
});

app.post('/postes', (req, res) => {
  const poste = req.body;
  // Rien ne vérifie le corps à notre place : il faut tout tester à la main.
  if (!poste || typeof poste.numero !== 'string' || !TYPES.includes(poste.type_poste)
      || !Number.isInteger(poste.prix_ht) || poste.prix_ht < 0) {
    return res.sendStatus(422);
  }
  if (postes.some((p) => p.numero === poste.numero)) return res.sendStatus(409);
  postes.push(poste);
  res.status(201).json(poste);
});

app.listen(3001, () => console.log('API du parc sur http://127.0.0.1:3001'));