axion 0.0.4

Automatic API generator that creates a REST API mirror of a database in Rust
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105

// src/api/health/routes.rs

use axum::{
    Json, Router,
    extract::State,
    routing::{get, post},
};
use chrono::{DateTime, Utc};
use serde::Serialize;
use std::{
    sync::{Arc, Mutex},
    time::{Duration, SystemTime},
};

// Type for the application state
pub type SharedAppState = Arc<Mutex<AppState>>;

// App state structure
pub struct AppState {
    pub start_time: SystemTime,
    pub database_connected: bool,
}

// Health check response model
#[derive(Serialize)]
pub struct HealthResponse {
    status: String,
    timestamp: String,
    version: String,
    uptime: f64,
    database_connected: bool,
}

// Cache status response model
#[derive(Serialize)]
pub struct CacheStatus {
    last_updated: String,
    total_items: i32,
    tables_cached: i32,
    views_cached: i32,
    enums_cached: i32,
    functions_cached: i32,
}

// Handler for the main health check endpoint
async fn health_check(State(state): State<SharedAppState>) -> Json<HealthResponse> {
    let state = state.lock().unwrap();
    let now = SystemTime::now();
    let uptime = now
        .duration_since(state.start_time)
        .unwrap_or(Duration::from_secs(0))
        .as_secs_f64();

    // Convert SystemTime to ISO 8601 format
    let datetime: DateTime<Utc> = now.into();

    Json(HealthResponse {
        status: if state.database_connected {
            "healthy".to_string()
        } else {
            "degraded".to_string()
        },
        timestamp: datetime.to_rfc3339(),
        version: env!("CARGO_PKG_VERSION").to_string(),
        uptime,
        database_connected: state.database_connected,
    })
}

// Simple ping handler for load balancer health checks
async fn ping() -> &'static str {
    "pong"
}

// Handler for checking cache status
async fn cache_status() -> Json<CacheStatus> {
    let now: DateTime<Utc> = SystemTime::now().into();

    Json(CacheStatus {
        last_updated: now.to_rfc3339(),
        total_items: 0,
        tables_cached: 0,
        views_cached: 0,
        enums_cached: 0,
        functions_cached: 0,
    })
}

// Handler for clearing metadata cache
async fn clear_cache() -> Json<serde_json::Value> {
    // In a real implementation, this would actually clear some cache
    Json(serde_json::json!({
        "status": "success",
        "message": "Cache cleared and reloaded successfully"
    }))
}

// Function to create the health routes router
pub fn create_health_routes() -> Router<SharedAppState> {
    Router::new()
        .route("/", get(health_check))
        .route("/ping", get(ping))
        .route("/cache", get(cache_status))
        .route("/clear-cache", post(clear_cache))
}