cot 0.6.0

The Rust web framework for lazy developers.
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

//! Database-backed session management backend.
//!
//! This module provides a session type and an app for storing session data
//! in a database using the Cot ORM.
pub mod migrations;

use cot::db::migrations::SyncDynMigration;

use crate::App;
use crate::db::{Auto, model};

/// Session data stored in the database.
#[derive(Debug, Clone)]
#[model]
pub struct Session {
    #[model(primary_key)]
    pub(crate) id: Auto<i32>,
    #[model(unique)]
    pub(crate) key: String,
    pub(crate) data: String,
    pub(crate) expiry: chrono::DateTime<chrono::FixedOffset>,
}

/// An app that provides session management via a session model stored in the
/// database.
///
/// This app registers the session model and its migrations, enabling persistent
/// session storage in the database.
///
/// # Examples
///
/// ```no_run
/// use cot::config::{DatabaseConfig, ProjectConfig};
/// use cot::project::RegisterAppsContext;
/// use cot::session::db::SessionApp;
/// use cot::{App, AppBuilder, Project};
///
/// struct MyProject;
/// impl Project for MyProject {
///     fn config(&self, config_name: &str) -> cot::Result<ProjectConfig> {
///         Ok(ProjectConfig::builder()
///             .database(DatabaseConfig::builder().url("sqlite::memory:").build())
///             .build())
///     }
///
///     fn register_apps(&self, apps: &mut AppBuilder, _context: &RegisterAppsContext) {
///         apps.register_with_views(SessionApp::new(), "");
///     }
/// }
///
/// #[cot::main]
/// fn main() -> impl Project {
///     MyProject
/// }
/// ```

#[derive(Debug, Copy, Clone)]
#[non_exhaustive]
pub struct SessionApp;

impl SessionApp {
    /// Create a new instance of the session management app.
    ///
    /// # Examples
    ///
    /// ```
    /// use cot::session::db::SessionApp;
    /// let app = SessionApp::new();
    /// ```
    #[must_use]
    pub fn new() -> Self {
        Self {}
    }
}

impl Default for SessionApp {
    fn default() -> Self {
        Self::new()
    }
}

impl App for SessionApp {
    fn name(&self) -> &'static str {
        "cot_session"
    }

    fn migrations(&self) -> Vec<Box<SyncDynMigration>> {
        cot::db::migrations::wrap_migrations(migrations::MIGRATIONS)
    }
}

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

    #[test]
    fn test_session_app_basic_behavior() {
        let app1 = SessionApp::new();

        let app2 = SessionApp::default();

        assert_eq!(app1.name(), "cot_session");
        assert_eq!(app2.name(), "cot_session");

        let migrations = app1.migrations();
        assert!(!migrations.is_empty());
    }
}