axa 0.2.0

Small shared library for services built directly on Axum.
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

//! A small type-keyed store for values shared across handlers.
//!
//! ```
//! use axa::store::Store;
//!
//! let store = Store::default();
//! store.insert(42_u32);
//! assert_eq!(store.get::<u32>(), Some(42));
//! ```

use std::{
    any::{Any, TypeId},
    collections::HashMap,
    sync::{Arc, RwLock},
};

use axum::{
    extract::{FromRef, FromRequestParts},
    http::request::Parts,
};

use crate::{AppContext, Error, error::ErrorDetail};

/// Values keyed by type. Holds one value per type.
#[derive(Default)]
pub struct Store {
    values: RwLock<HashMap<TypeId, Arc<dyn Any + Send + Sync>>>,
}

impl std::fmt::Debug for Store {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str("Store")
    }
}

impl Store {
    /// Insert a value, replacing any earlier value of the same type.
    ///
    /// # Panics
    ///
    /// If a previous holder of the lock panicked.
    pub fn insert<T: Send + Sync + 'static>(&self, value: T) {
        self.values
            .write()
            .unwrap()
            .insert(TypeId::of::<T>(), Arc::new(value));
    }

    /// Get a shared handle to the value of type `T`.
    ///
    /// # Panics
    ///
    /// If a previous holder of the lock panicked.
    #[must_use]
    pub fn get_ref<T: Send + Sync + 'static>(&self) -> Option<Arc<T>> {
        let value = self.values.read().unwrap().get(&TypeId::of::<T>())?.clone();
        value.downcast::<T>().ok()
    }

    /// Get a clone of the value of type `T`.
    #[must_use]
    pub fn get<T: Clone + Send + Sync + 'static>(&self) -> Option<T> {
        self.get_ref::<T>().map(|value| (*value).clone())
    }

    /// Whether a value of type `T` is present.
    ///
    /// # Panics
    ///
    /// If a previous holder of the lock panicked.
    #[must_use]
    pub fn contains<T: Send + Sync + 'static>(&self) -> bool {
        self.values.read().unwrap().contains_key(&TypeId::of::<T>())
    }
}

/// Extractor that clones a value out of the context's [`Store`].
#[derive(Debug, Clone)]
pub struct SharedStore<T>(pub T);

impl<S, T> FromRequestParts<S> for SharedStore<T>
where
    S: Send + Sync,
    AppContext: FromRef<S>,
    T: Clone + Send + Sync + 'static,
{
    type Rejection = Error;

    #[allow(unknown_lints, clippy::unused_async_trait_impl)]
    async fn from_request_parts(_parts: &mut Parts, state: &S) -> Result<Self, Self::Rejection> {
        AppContext::from_ref(state)
            .shared_store
            .get::<T>()
            .map(Self)
            .ok_or_else(|| {
                Error::CustomError(
                    axum::http::StatusCode::INTERNAL_SERVER_ERROR,
                    ErrorDetail::new("internal_server_error", "Internal Server Error"),
                )
            })
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn stores_one_value_per_type() {
        let store = Store::default();
        store.insert(1_u32);
        store.insert(2_u32);
        store.insert("text".to_string());
        assert_eq!(store.get::<u32>(), Some(2));
        assert_eq!(store.get::<String>().as_deref(), Some("text"));
        assert!(!store.contains::<u8>());
    }
}