runique 2.2.0

A Django-inspired web framework for Rust with ORM, templates, and comprehensive security middleware
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

//! `RouterExt` — Axum `Router` extension to attach a rate limiter or a login guard to a route.
use std::sync::Arc;

use axum::{Router, http::Method, routing::MethodRouter};

use crate::auth::guard::login_required_middleware;
use crate::macros::routeur::register_url::register_pending;
use crate::middleware::rate_limit::{RateLimiter, rate_limit_middleware};

/// `RouterExt` extension to add routes with rate limiting in a fluent way.
///
/// # Example — single route
/// ```rust,ignore
/// urlpatterns! { ... }
///     .rate_limit("/upload-image", "upload_image", view!(upload_image_submit), 5, 60)
/// ```
///
/// # Example — multiple routes, shared counter
/// ```rust,ignore
/// urlpatterns! { ... }
///     .rate_limit_many(5, 60, vec![
///         ("/upload-image".into(), "upload_image".into(), view!(upload_image_submit)),
///         ("/inscription".into(),  "inscription".into(),  view!(registration_submission)),
///     ])
/// ```
pub trait RouterExt {
    /// Adds a route protected by `login_required` — redirects to `redirect_url` if not authenticated.
    ///
    /// # Example
    /// ```rust,ignore
    /// urlpatterns! { ... }
    ///     .login_required("/profil", "profil", view!(profil), "/login")
    /// ```
    fn login_required(
        self,
        path: impl Into<String>,
        name: impl Into<String>,
        handler: MethodRouter,
        redirect_url: impl Into<String>,
    ) -> Self;

    /// Adds a route protected by a rate limiter.
    /// `methods`: HTTP methods to count — empty vec counts all methods.
    fn rate_limit(
        self,
        path: impl Into<String>,
        name: impl Into<String>,
        handler: MethodRouter,
        max_requests: u32,
        retry_after: u64,
        methods: Vec<Method>,
    ) -> Self;

    /// Adds multiple routes sharing the same rate limiter (common counter).
    /// `methods`: HTTP methods to count — empty vec counts all methods.
    fn rate_limit_many(
        self,
        max_requests: u32,
        retry_after: u64,
        methods: Vec<Method>,
        routes: Vec<(String, String, MethodRouter)>,
    ) -> Self;
}

impl RouterExt for Router {
    fn login_required(
        self,
        path: impl Into<String>,
        name: impl Into<String>,
        handler: MethodRouter,
        redirect_url: impl Into<String>,
    ) -> Self {
        let path = path.into();
        let name = name.into();
        let redirect = Arc::new(redirect_url.into());
        register_pending(&name, &path);
        let protected =
            Router::new()
                .route(&path, handler)
                .route_layer(axum::middleware::from_fn_with_state(
                    redirect,
                    login_required_middleware,
                ));
        self.merge(protected)
    }

    fn rate_limit(
        self,
        path: impl Into<String>,
        name: impl Into<String>,
        handler: MethodRouter,
        max_requests: u32,
        retry_after: u64,
        methods: Vec<Method>,
    ) -> Self {
        self.rate_limit_many(
            max_requests,
            retry_after,
            methods,
            vec![(path.into(), name.into(), handler)],
        )
    }

    fn rate_limit_many(
        self,
        max_requests: u32,
        retry_after: u64,
        methods: Vec<Method>,
        routes: Vec<(String, String, MethodRouter)>,
    ) -> Self {
        let mut limiter = RateLimiter::new()
            .max_requests(max_requests)
            .retry_after(retry_after);
        if !methods.is_empty() {
            limiter = limiter.only_methods(methods);
        }
        let limiter = Arc::new(limiter);
        limiter.spawn_cleanup(tokio::time::Duration::from_secs(retry_after));
        let mut r = self;
        for (path, name, handler) in routes {
            register_pending(&name, &path);
            let limited = Router::new().route(&path, handler).route_layer(
                axum::middleware::from_fn_with_state(limiter.clone(), rate_limit_middleware),
            );
            r = r.merge(limited);
        }
        r
    }
}