ironic 1.0.8

A batteries-included, type-safe application framework for 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
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144

//! Read-only development UI for compiled modules, providers, and routes.

use std::sync::Arc;

use axum::{Json, Router, extract::State, response::Html, routing::get};
use serde::Serialize;

use crate::{CompiledApplicationGraph, CompiledHttpApplication};

/// Serializable application graph and route snapshot.
#[derive(Clone, Debug, Serialize)]
pub struct DevtoolsSnapshot {
    /// Root module type name.
    pub root: String,
    /// Compiled modules in initialization order.
    pub modules: Vec<ModuleSnapshot>,
    /// Compiled HTTP routes.
    pub routes: Vec<RouteSnapshot>,
}

/// Serializable module details.
#[derive(Clone, Debug, Serialize)]
pub struct ModuleSnapshot {
    /// Module type name.
    pub name: String,
    /// Direct imported module type names.
    pub imports: Vec<String>,
    /// Owned provider type names and scopes.
    pub providers: Vec<ProviderSnapshot>,
}

/// Serializable provider details.
#[derive(Clone, Debug, Serialize)]
pub struct ProviderSnapshot {
    /// Provider type name.
    pub name: String,
    /// `Singleton`, `Transient`, or `Request`.
    pub scope: String,
    /// Declared dependency type names.
    pub dependencies: Vec<String>,
}

/// Serializable route details.
#[derive(Clone, Debug, Serialize)]
pub struct RouteSnapshot {
    /// HTTP method.
    pub method: String,
    /// Normalized path.
    pub path: String,
    /// Owning controller type.
    pub controller: String,
    /// Handler method name.
    pub handler: String,
}

impl DevtoolsSnapshot {
    /// Captures immutable metadata from compiled runtime state.
    #[must_use]
    pub fn capture(graph: &CompiledApplicationGraph, http: &CompiledHttpApplication) -> Self {
        let modules = graph
            .modules()
            .iter()
            .map(|module| ModuleSnapshot {
                name: module.id().type_name().into(),
                imports: module
                    .imports()
                    .iter()
                    .map(|id| id.type_name().into())
                    .collect(),
                providers: module
                    .providers()
                    .iter()
                    .map(|provider| ProviderSnapshot {
                        name: provider.key().type_name().into(),
                        scope: format!("{:?}", provider.scope()),
                        dependencies: provider
                            .dependencies()
                            .iter()
                            .map(|dependency| dependency.key().type_name().into())
                            .collect(),
                    })
                    .collect(),
            })
            .collect();
        let routes = http
            .routes()
            .iter()
            .map(|route| RouteSnapshot {
                method: route.method().to_string(),
                path: route.path().into(),
                controller: route.controller().type_name().into(),
                handler: route.handler_name().into(),
            })
            .collect();
        Self {
            root: graph.root().type_name().into(),
            modules,
            routes,
        }
    }
}

/// Builds a read-only Axum UI router. Mount it only in trusted development environments.
pub fn router(snapshot: DevtoolsSnapshot) -> Router {
    Router::new()
        .route("/", get(index))
        .route("/snapshot.json", get(snapshot_json))
        .with_state(Arc::new(snapshot))
}

async fn snapshot_json(State(snapshot): State<Arc<DevtoolsSnapshot>>) -> Json<DevtoolsSnapshot> {
    Json((*snapshot).clone())
}

async fn index(State(snapshot): State<Arc<DevtoolsSnapshot>>) -> Html<String> {
    use std::fmt::Write;

    let mut rows = String::new();
    for route in &snapshot.routes {
        let _ = write!(
            rows,
            "<tr><td>{}</td><td>{}</td><td>{}::{}</td></tr>",
            escape(&route.method),
            escape(&route.path),
            escape(&route.controller),
            escape(&route.handler)
        );
    }
    Html(format!(
        "<!doctype html><html><head><meta charset=\"utf-8\"><title>Ironic Devtools</title><style>body{{font:14px system-ui;margin:2rem;max-width:1100px}}table{{border-collapse:collapse;width:100%}}td,th{{border:1px solid #ddd;padding:.6rem;text-align:left}}code{{background:#f4f4f4;padding:.15rem .3rem}}</style></head><body><h1>Ironic Devtools</h1><p>Root module: <code>{}</code></p><p>{} modules · {} routes · <a href=\"snapshot.json\">JSON snapshot</a></p><table><thead><tr><th>Method</th><th>Path</th><th>Handler</th></tr></thead><tbody>{rows}</tbody></table></body></html>",
        escape(&snapshot.root),
        snapshot.modules.len(),
        snapshot.routes.len()
    ))
}

fn escape(value: &str) -> String {
    value
        .replace('&', "&amp;")
        .replace('<', "&lt;")
        .replace('>', "&gt;")
        .replace('"', "&quot;")
        .replace('\'', "&#39;")
}