actix_web_flash_messages/builder.rs
1use crate::storage::FlashMessageStore;
2use crate::Level;
3use std::sync::Arc;
4
5#[derive(Clone)]
6/// `actix-web` middleware providing support for sending and receiving [`FlashMessage`]s.
7///
8/// Use [`FlashMessagesFramework::builder`] to build an instance of [`FlashMessagesFramework`]!
9///
10/// ```rust
11/// use actix_web_flash_messages::{FlashMessagesFramework, storage::CookieMessageStore};
12/// use actix_web::{HttpServer, App, web, cookie::Key};
13///
14/// #[actix_web::main]
15/// async fn main() {
16/// let signing_key = Key::generate(); // This will usually come from configuration!
17/// let message_store = CookieMessageStore::builder(signing_key).build();
18/// let message_framework = FlashMessagesFramework::builder(message_store).build();
19///
20/// HttpServer::new(move || {
21/// App::new()
22/// .wrap(message_framework.clone())
23/// // [...] your endpoints
24/// })
25/// # ;
26/// }
27/// ```
28///
29/// [`FlashMessage`]: crate::FlashMessage
30pub struct FlashMessagesFramework {
31 pub(crate) minimum_level: Level,
32 pub(crate) storage_backend: Arc<dyn FlashMessageStore>,
33}
34
35impl FlashMessagesFramework {
36 /// A fluent API to configure [`FlashMessagesFramework`].
37 ///
38 /// It takes as input a **message store**, the only required piece of configuration.
39 ///
40 /// `actix-web-flash-messages` provides a cookie-based implementation of flash messages, [`CookieMessageStore`],
41 /// using a signed cookie to store and retrieve messages.
42 /// You can provide your own custom message store backend by implementing the [`FlashMessageStore`] trait.
43 ///
44 /// [`CookieMessageStore`]: crate::storage::CookieMessageStore
45 pub fn builder<S: FlashMessageStore + 'static>(
46 storage_backend: S,
47 ) -> FlashMessagesFrameworkBuilder {
48 FlashMessagesFrameworkBuilder {
49 minimum_level: None,
50 storage_backend: Arc::new(storage_backend),
51 }
52 }
53}
54
55/// A fluent builder to construct a [`FlashMessagesFramework`] instance.
56pub struct FlashMessagesFrameworkBuilder {
57 pub(crate) minimum_level: Option<Level>,
58 pub(crate) storage_backend: Arc<dyn FlashMessageStore>,
59}
60
61impl FlashMessagesFrameworkBuilder {
62 /// By default, [`FlashMessagesFramework`] will only dispatch messages at `info`-level or above, discarding `debug`-level messages.
63 /// You can change this behaviour using this method:
64 ///
65 /// ```rust
66 /// use actix_web_flash_messages::{FlashMessagesFramework, Level, storage::CookieMessageStore};
67 /// use actix_web::{HttpServer, App, web};
68 ///
69 /// fn get_message_store() -> CookieMessageStore {
70 /// // [...]
71 /// # CookieMessageStore::builder(actix_web::cookie::Key::generate()).build()
72 /// }
73 ///
74 /// #[actix_web::main]
75 /// async fn main() {
76 /// // Show debug-level messages when developing locally
77 /// let minimum_level = match std::env::var("APP_ENV") {
78 /// Ok(s) if &s == "local" => Level::Debug,
79 /// _ => Level::Info,
80 /// };
81 /// let message_framework = FlashMessagesFramework::builder(get_message_store())
82 /// .minimum_level(minimum_level)
83 /// .build();
84 ///
85 /// HttpServer::new(move || {
86 /// App::new()
87 /// .wrap(message_framework.clone())
88 /// // [...] Your endpoints
89 /// })
90 /// # ;
91 /// }
92 /// ```
93 pub fn minimum_level(mut self, minimum_level: Level) -> Self {
94 self.minimum_level = Some(minimum_level);
95 self
96 }
97
98 /// Finalise the builder and return a [`FlashMessagesFramework`] instance.
99 pub fn build(self) -> FlashMessagesFramework {
100 FlashMessagesFramework {
101 minimum_level: self.minimum_level.unwrap_or(Level::Info),
102 storage_backend: self.storage_backend,
103 }
104 }
105}