ferro-inertia 0.2.24

Server-side Inertia.js adapter for Rust web frameworks
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

//! Shared props that are merged into every Inertia response.

use serde::Serialize;

/// Shared props that are merged into every Inertia response.
///
/// Use this struct to pass common data (auth, flash messages, CSRF tokens)
/// to all Inertia responses via middleware.
///
/// # Example
///
/// ```rust
/// use ferro_inertia::InertiaShared;
/// use serde_json::json;
///
/// let shared = InertiaShared::new()
///     .auth(json!({
///         "id": 1,
///         "name": "John Doe",
///         "email": "john@example.com"
///     }))
///     .csrf("token123")
///     .flash(json!({
///         "success": "Profile updated!"
///     }));
/// ```
#[derive(Clone, Default, Debug, Serialize)]
pub struct InertiaShared {
    /// Authenticated user data (if any)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub auth: Option<serde_json::Value>,
    /// Flash messages from the session
    #[serde(skip_serializing_if = "Option::is_none")]
    pub flash: Option<serde_json::Value>,
    /// CSRF token
    #[serde(skip_serializing_if = "Option::is_none")]
    pub csrf: Option<String>,
    /// Additional custom shared props
    #[serde(flatten, skip_serializing_if = "Option::is_none")]
    pub extra: Option<serde_json::Value>,
}

impl InertiaShared {
    /// Create a new empty shared props container.
    pub fn new() -> Self {
        Self::default()
    }

    /// Set authenticated user data.
    pub fn auth(mut self, auth: impl Serialize) -> Self {
        self.auth = Some(serde_json::to_value(auth).unwrap_or_default());
        self
    }

    /// Set flash messages.
    pub fn flash(mut self, flash: impl Serialize) -> Self {
        self.flash = Some(serde_json::to_value(flash).unwrap_or_default());
        self
    }

    /// Set CSRF token.
    pub fn csrf(mut self, token: impl Into<String>) -> Self {
        self.csrf = Some(token.into());
        self
    }

    /// Set additional custom shared props.
    ///
    /// These will be flattened into the shared props object.
    pub fn with(mut self, extra: impl Serialize) -> Self {
        self.extra = Some(serde_json::to_value(extra).unwrap_or_default());
        self
    }

    /// Merge shared props into a props object.
    pub fn merge_into(&self, props: &mut serde_json::Value) {
        if let serde_json::Value::Object(ref mut map) = props {
            if let Some(auth) = &self.auth {
                map.insert("auth".to_string(), auth.clone());
            }
            if let Some(flash) = &self.flash {
                map.insert("flash".to_string(), flash.clone());
            }
            if let Some(csrf) = &self.csrf {
                map.insert("csrf".to_string(), serde_json::Value::String(csrf.clone()));
            }
            if let Some(serde_json::Value::Object(extra_map)) = &self.extra {
                for (k, v) in extra_map {
                    map.insert(k.clone(), v.clone());
                }
            }
        }
    }
}