webapp 2.0.0

A web application completely written in Rust
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
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152

use leptos::prelude::*;
use leptos_meta::{MetaTags, Stylesheet, Title, provide_meta_context};
use leptos_router::{
    StaticSegment,
    components::{Route, Router, Routes},
};

use crate::pages::{content::ContentPage, login::LoginPage};

pub fn shell(options: LeptosOptions) -> impl IntoView {
    view! {
        <!DOCTYPE html>
        <html lang="en">
            <head>
                <meta charset="utf-8"/>
                <meta name="viewport" content="width=device-width, initial-scale=1"/>
                <AutoReload options=options.clone()/>
                <HydrationScripts options/>
                <MetaTags/>
            </head>
            <body>
                <App/>
            </body>
        </html>
    }
}

#[component]
pub fn App() -> impl IntoView {
    provide_meta_context();

    view! {
        <Stylesheet id="leptos" href="/pkg/webapp.css"/>
        <Title text="WebApp.rs"/>
        <Router>
            <main>
                <Routes fallback=|| "Page not found.".into_view()>
                    <Route path=StaticSegment("") view=LoginPage/>
                    <Route path=StaticSegment("content") view=ContentPage/>
                </Routes>
            </main>
        </Router>
    }
}

#[server]
pub async fn register(username: String, password: String) -> Result<(), ServerFnError> {
    use crate::{auth, database};

    if username.is_empty() || password.is_empty() {
        return Err(ServerFnError::new("Username and password are required"));
    }

    if username.len() > 64 || password.len() > 128 {
        return Err(ServerFnError::new("Input too long"));
    }

    if database::user_exists(&username)
        .await
        .map_err(|e| ServerFnError::new(e.to_string()))?
    {
        return Err(ServerFnError::new("User already exists"));
    }

    let hash = auth::hash_password(&password).map_err(ServerFnError::new)?;
    database::create_user(&username, &hash)
        .await
        .map_err(|e| ServerFnError::new(e.to_string()))?;

    Ok(())
}

#[server]
pub async fn login(username: String, password: String) -> Result<String, ServerFnError> {
    use crate::{auth, database};

    if username.is_empty() || password.is_empty() {
        return Err(ServerFnError::new("Invalid credentials"));
    }

    let hash = database::get_password_hash(&username)
        .await
        .map_err(|e| ServerFnError::new(e.to_string()))?
        .ok_or_else(|| ServerFnError::new("Invalid credentials"))?;

    if !auth::verify_password(&password, &hash).map_err(ServerFnError::new)? {
        return Err(ServerFnError::new("Invalid credentials"));
    }

    let token = auth::create_token(&username).map_err(|e| ServerFnError::new(e.to_string()))?;
    let expires_at = auth::token_expiry();
    database::create_session(&token, &username, expires_at)
        .await
        .map_err(|e| ServerFnError::new(e.to_string()))?;

    Ok(token)
}

#[server]
pub async fn renew_session(token: String) -> Result<String, ServerFnError> {
    use crate::{auth, database};

    let username = auth::verify_token(&token).map_err(|e| ServerFnError::new(e.to_string()))?;

    if !database::session_exists(&token)
        .await
        .map_err(|e| ServerFnError::new(e.to_string()))?
    {
        return Err(ServerFnError::new("Session not found"));
    }

    let new_token = auth::create_token(&username).map_err(|e| ServerFnError::new(e.to_string()))?;
    let expires_at = auth::token_expiry();
    database::update_session(&token, &new_token, expires_at)
        .await
        .map_err(|e| ServerFnError::new(e.to_string()))?;

    Ok(new_token)
}

#[server]
pub async fn whoami(token: String) -> Result<String, ServerFnError> {
    use crate::{auth, database};

    let username = auth::verify_token(&token).map_err(|e| ServerFnError::new(e.to_string()))?;

    if !database::session_exists(&token)
        .await
        .map_err(|e| ServerFnError::new(e.to_string()))?
    {
        return Err(ServerFnError::new("Session not found"));
    }

    Ok(username)
}

#[server]
pub async fn logout(token: String) -> Result<(), ServerFnError> {
    use crate::{auth, database};

    // Verify the token is valid before attempting deletion
    auth::verify_token(&token).map_err(|e| ServerFnError::new(e.to_string()))?;

    if !database::delete_session(&token)
        .await
        .map_err(|e| ServerFnError::new(e.to_string()))?
    {
        return Err(ServerFnError::new("Session not found"));
    }

    Ok(())
}