debt-pirate/api/src/requests/mod.rs

mod user;

use std::time::Duration;

use axum::{
    extract::{MatchedPath, Request},
    response::Response,
    Router,
};
use tokio::net::TcpListener;
use tower_http::trace::TraceLayer;
use tracing::{error, info, info_span, warn, Span};

use crate::{
    db::DbPool,
    models::{AppError, Environment},
};

#[derive(Clone)]
pub struct AppState {
    pool: DbPool,
    env: Environment,
}

impl AppState {
    pub fn new(pool: DbPool, env: Environment) -> Self {
        Self { pool, env }
    }

    pub fn pool(&self) -> &DbPool {
        &self.pool
    }

    pub fn env(&self) -> &Environment {
        &self.env
    }
}

pub async fn start_app(pool: DbPool, env: Environment) -> Result<(), AppError> {
    let address = env.hostname();
    let port = env.port();

    info!("Listening on {address}:{port}...");
    let listener = TcpListener::bind(format!("{address}:{port}"))
        .await
        .unwrap();

    let logging_layer = TraceLayer::new_for_http()
		.make_span_with(|request: &Request| {
			let request_path = request
				.extensions()
				.get::<MatchedPath>()
				.map(MatchedPath::as_str).unwrap();

			info_span!("http_request", method = %request.method(), path = %request_path, status = tracing::field::Empty)
		})
		.on_response(|response: &Response, _duration: Duration, _span: &Span| {
			let status = response.status();

			_span.record("status", status.to_string());

			match status.as_u16() {
				w if (300..400).contains(&w) => warn!(""),
				e if e >= 400 => error!(""),
				_ => info!("")
			}
		});

    let app_state = AppState::new(pool, env);
    let app = Router::new()
        .merge(user::requests(app_state.clone()))
        .layer(logging_layer);

    info!("API started successfully.");
    axum::serve(listener, app)
        .await
        .map_err(AppError::app_startup)?;

    Ok(())
}