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

mod auth;
mod user;

use std::time::Duration;

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

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 path = request
				.extensions()
				.get::<MatchedPath>()
				.map(MatchedPath::as_str).unwrap_or(request.uri().path());

			info_span!("api_request", request_id = %Ulid::new(), method = %request.method(), %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 {
				w if w.is_redirection() => warn!(duration = ?format_duration(duration).to_string()),
				e if e.is_client_error() || e.is_server_error() => error!(duration = ?format_duration(duration).to_string()),
				_ => info!(duration = ?format_duration(duration).to_string())
			}
		});

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

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

    Ok(())
}