API Rust pour convertir LaTeX en PDF

use reqwest::Client;
use serde_json::json;
use std::fs;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let api_key = std::env::var("FORMATEX_API_KEY")?;

    let latex = r#"\documentclass{article}
\usepackage{amsmath}
\begin{document}
Hello from Rust! $E = mc^2$
\end{document}"#;

    let client = Client::new();
    let response = client
        .post("https://api.formatex.io/api/v1/compile")
        .header("X-API-Key", &api_key)
        .json(&json!({ "latex": latex, "engine": "pdflatex" }))
        .send()
        .await?;

    if !response.status().is_success() {
        let body = response.text().await?;
        return Err(format!("API error: {body}").into());
    }

    let pdf = response.bytes().await?;
    fs::write("output.pdf", &pdf)?;
    println!("PDF saved to output.pdf");
    Ok(())
}

use axum::{
    body::Bytes,
    extract::State,
    http::{HeaderMap, StatusCode},
    response::{IntoResponse, Response},
    Json,
};
use reqwest::Client;
use serde::Deserialize;

#[derive(Clone)]
pub struct AppState {
    pub http:    Client,
    pub api_key: String,
}

#[derive(Deserialize)]
pub struct CompileRequest {
    pub source: String,
    #[serde(default = "default_engine")]
    pub engine: String,
}

fn default_engine() -> String {
    "pdflatex".to_string()
}

pub async fn compile_handler(
    State(state): State<AppState>,
    Json(body):   Json<CompileRequest>,
) -> Result<Response, (StatusCode, String)> {
    let res = state
        .http
        .post("https://api.formatex.io/api/v1/compile")
        .header("X-API-Key", &state.api_key)
        .json(&serde_json::json!({
            "latex": body.source,
            "engine": body.engine,
        }))
        .send()
        .await
        .map_err(|e| (StatusCode::BAD_GATEWAY, e.to_string()))?;

    if !res.status().is_success() {
        let msg = res.text().await.unwrap_or_default();
        return Err((StatusCode::UNPROCESSABLE_ENTITY, msg));
    }

    let pdf: Bytes = res
        .bytes()
        .await
        .map_err(|e| (StatusCode::INTERNAL_SERVER_ERROR, e.to_string()))?;

    let mut headers = HeaderMap::new();
    headers.insert("Content-Type", "application/pdf".parse().unwrap());
    headers.insert(
        "Content-Disposition",
        "attachment; filename=output.pdf".parse().unwrap(),
    );

    Ok((headers, pdf).into_response())
}