connor/calendar
1
0
Fork 0
Code Issues 2 Pull Requests Actions Packages Projects Releases Wiki Activity

Implement lightweight auth system with SQLite

Browse Source 
Added SQLite database for session management and user preferences storage,
allowing users to have consistent settings across different sessions and devices.

Backend changes:
- Added SQLite database with users, sessions, and preferences tables
- Implemented session-based authentication alongside JWT tokens
- Created preference storage/retrieval API endpoints
- Database migrations for schema setup
- Session validation and cleanup functionality

Frontend changes:
- Added "Remember server" and "Remember username" checkboxes to login
- Created preferences service for syncing settings with backend
- Updated auth flow to handle session tokens and preferences
- Store remembered values in LocalStorage (not database) for convenience

Key features:
- User preferences persist across sessions and devices
- CalDAV passwords never stored, only passed through
- Sessions expire after 24 hours
- Remember checkboxes only affect local browser storage

🤖 Generated with [Claude Code](https://claude.ai/code)

Co-Authored-By: Claude <noreply@anthropic.com>
This commit is contained in:
Connor Johnstone
2025-09-01 18:55:09 -04:00
parent 79f287ed61
commit 03c0011445
17 changed files with 888 additions and 47 deletions
Download Patch File Download Diff File Expand all files Collapse all files

11
frontend/src/auth.rs
View File

@@ -11,11 +11,22 @@ pub struct CalDAVLoginRequest {
pub password: String,
}
#[derive(Debug, Serialize, Deserialize, Clone)]
pub struct UserPreferencesResponse {
pub calendar_selected_date: Option<String>,
pub calendar_time_increment: Option<i32>,
pub calendar_view_mode: Option<String>,
pub calendar_theme: Option<String>,
pub calendar_colors: Option<String>,
}
#[derive(Debug, Serialize, Deserialize)]
pub struct AuthResponse {
pub token: String,
pub session_token: String,
pub username: String,
pub server_url: String,
pub preferences: UserPreferencesResponse,
}
#[derive(Debug, Deserialize)]

94
frontend/src/components/login.rs
View File

@@ -9,11 +9,24 @@ pub struct LoginProps {
#[function_component]
pub fn Login(props: &LoginProps) -> Html {
let server_url = use_state(String::new);
let username = use_state(String::new);
// Load remembered values from LocalStorage on mount
let server_url = use_state(|| {
LocalStorage::get::<String>("remembered_server_url").unwrap_or_default()
});
let username = use_state(|| {
LocalStorage::get::<String>("remembered_username").unwrap_or_default()
});
let password = use_state(String::new);
let error_message = use_state(|| Option::<String>::None);
let is_loading = use_state(|| false);
// Remember checkboxes state
let remember_server = use_state(|| {
LocalStorage::get::<String>("remembered_server_url").is_ok()
});
let remember_username = use_state(|| {
LocalStorage::get::<String>("remembered_username").is_ok()
});
let server_url_ref = use_node_ref();
let username_ref = use_node_ref();
@@ -42,6 +55,38 @@ pub fn Login(props: &LoginProps) -> Html {
password.set(target.value());
})
};
let on_remember_server_change = {
let remember_server = remember_server.clone();
let server_url = server_url.clone();
Callback::from(move |e: Event| {
let target = e.target_unchecked_into::<HtmlInputElement>();
let checked = target.checked();
remember_server.set(checked);
if checked {
let _ = LocalStorage::set("remembered_server_url", (*server_url).clone());
} else {
let _ = LocalStorage::delete("remembered_server_url");
}
})
};
let on_remember_username_change = {
let remember_username = remember_username.clone();
let username = username.clone();
Callback::from(move |e: Event| {
let target = e.target_unchecked_into::<HtmlInputElement>();
let checked = target.checked();
remember_username.set(checked);
if checked {
let _ = LocalStorage::set("remembered_username", (*username).clone());
} else {
let _ = LocalStorage::delete("remembered_username");
}
})
};
let on_submit = {
let server_url = server_url.clone();
@@ -73,7 +118,7 @@ pub fn Login(props: &LoginProps) -> Html {
wasm_bindgen_futures::spawn_local(async move {
web_sys::console::log_1(&"🚀 Starting login process...".into());
match perform_login(server_url.clone(), username.clone(), password.clone()).await {
Ok((token, credentials)) => {
Ok((token, session_token, credentials, preferences)) => {
web_sys::console::log_1(&"✅ Login successful!".into());
// Store token and credentials in local storage
if let Err(_) = LocalStorage::set("auth_token", &token) {
@@ -82,11 +127,22 @@ pub fn Login(props: &LoginProps) -> Html {
is_loading.set(false);
return;
}
if let Err(_) = LocalStorage::set("session_token", &session_token) {
error_message
.set(Some("Failed to store session token".to_string()));
is_loading.set(false);
return;
}
if let Err(_) = LocalStorage::set("caldav_credentials", &credentials) {
error_message.set(Some("Failed to store credentials".to_string()));
is_loading.set(false);
return;
}
// Store preferences from database
if let Ok(prefs_json) = serde_json::to_string(&preferences) {
let _ = LocalStorage::set("user_preferences", &prefs_json);
}
is_loading.set(false);
on_login.emit(token);
@@ -117,6 +173,15 @@ pub fn Login(props: &LoginProps) -> Html {
onchange={on_server_url_change}
disabled={*is_loading}
/>
<div class="remember-checkbox">
<input
type="checkbox"
id="remember_server"
checked={*remember_server}
onchange={on_remember_server_change}
/>
<label for="remember_server">{"Remember server"}</label>
</div>
</div>
<div class="form-group">
@@ -130,6 +195,15 @@ pub fn Login(props: &LoginProps) -> Html {
onchange={on_username_change}
disabled={*is_loading}
/>
<div class="remember-checkbox">
<input
type="checkbox"
id="remember_username"
checked={*remember_username}
onchange={on_remember_username_change}
/>
<label for="remember_username">{"Remember username"}</label>
</div>
</div>
<div class="form-group">
@@ -177,7 +251,7 @@ async fn perform_login(
server_url: String,
username: String,
password: String,
) -> Result<(String, String), String> {
) -> Result<(String, String, String, serde_json::Value), String> {
use crate::auth::{AuthService, CalDAVLoginRequest};
use serde_json;
@@ -201,7 +275,17 @@ async fn perform_login(
"username": username,
"password": password
});
Ok((response.token, credentials.to_string()))
// Extract preferences as JSON
let preferences = serde_json::json!({
"calendar_selected_date": response.preferences.calendar_selected_date,
"calendar_time_increment": response.preferences.calendar_time_increment,
"calendar_view_mode": response.preferences.calendar_view_mode,
"calendar_theme": response.preferences.calendar_theme,
"calendar_colors": response.preferences.calendar_colors,
});
Ok((response.token, response.session_token, credentials.to_string(), preferences))
}
Err(err) => {
web_sys::console::log_1(&format!("❌ Backend error: {}", err).into());

2
frontend/src/services/mod.rs
View File

@@ -1,3 +1,5 @@
pub mod calendar_service;
pub mod preferences;
pub use calendar_service::CalendarService;
pub use preferences::PreferencesService;

177
frontend/src/services/preferences.rs Normal file
View File

@@ -0,0 +1,177 @@
use gloo_storage::{LocalStorage, Storage};
use serde::{Deserialize, Serialize};
use serde_json;
use wasm_bindgen::JsCast;
use wasm_bindgen_futures::JsFuture;
use web_sys::{Request, RequestInit, RequestMode, Response};
#[derive(Debug, Serialize, Deserialize, Clone)]
pub struct UserPreferences {
pub calendar_selected_date: Option<String>,
pub calendar_time_increment: Option<i32>,
pub calendar_view_mode: Option<String>,
pub calendar_theme: Option<String>,
pub calendar_colors: Option<String>,
}
#[derive(Debug, Serialize)]
pub struct UpdatePreferencesRequest {
pub calendar_selected_date: Option<String>,
pub calendar_time_increment: Option<i32>,
pub calendar_view_mode: Option<String>,
pub calendar_theme: Option<String>,
pub calendar_colors: Option<String>,
}
pub struct PreferencesService {
base_url: String,
}
impl PreferencesService {
pub fn new() -> Self {
let base_url = option_env!("BACKEND_API_URL")
.unwrap_or("http://localhost:3000/api")
.to_string();
Self { base_url }
}
/// Load preferences from LocalStorage (cached from login)
pub fn load_cached() -> Option<UserPreferences> {
if let Ok(prefs_json) = LocalStorage::get::<String>("user_preferences") {
serde_json::from_str(&prefs_json).ok()
} else {
None
}
}
/// Update a single preference field and sync with backend
pub async fn update_preference(&self, field: &str, value: serde_json::Value) -> Result<(), String> {
// Get session token
let session_token = LocalStorage::get::<String>("session_token")
.map_err(|_| "No session token found".to_string())?;
// Load current preferences
let mut preferences = Self::load_cached().unwrap_or(UserPreferences {
calendar_selected_date: None,
calendar_time_increment: None,
calendar_view_mode: None,
calendar_theme: None,
calendar_colors: None,
});
// Update the specific field
match field {
"calendar_selected_date" => {
preferences.calendar_selected_date = value.as_str().map(|s| s.to_string());
}
"calendar_time_increment" => {
preferences.calendar_time_increment = value.as_i64().map(|i| i as i32);
}
"calendar_view_mode" => {
preferences.calendar_view_mode = value.as_str().map(|s| s.to_string());
}
"calendar_theme" => {
preferences.calendar_theme = value.as_str().map(|s| s.to_string());
}
"calendar_colors" => {
preferences.calendar_colors = value.as_str().map(|s| s.to_string());
}
_ => return Err(format!("Unknown preference field: {}", field)),
}
// Save to LocalStorage cache
if let Ok(prefs_json) = serde_json::to_string(&preferences) {
let _ = LocalStorage::set("user_preferences", &prefs_json);
}
// Sync with backend
let request = UpdatePreferencesRequest {
calendar_selected_date: preferences.calendar_selected_date.clone(),
calendar_time_increment: preferences.calendar_time_increment,
calendar_view_mode: preferences.calendar_view_mode.clone(),
calendar_theme: preferences.calendar_theme.clone(),
calendar_colors: preferences.calendar_colors.clone(),
};
self.sync_preferences(&session_token, &request).await
}
/// Sync all preferences with backend
async fn sync_preferences(
&self,
session_token: &str,
request: &UpdatePreferencesRequest,
) -> Result<(), String> {
let window = web_sys::window().ok_or("No global window exists")?;
let json_body = serde_json::to_string(request)
.map_err(|e| format!("JSON serialization failed: {}", e))?;
let opts = RequestInit::new();
opts.set_method("POST");
opts.set_mode(RequestMode::Cors);
opts.set_body(&wasm_bindgen::JsValue::from_str(&json_body));
let url = format!("{}/preferences", self.base_url);
let request = Request::new_with_str_and_init(&url, &opts)
.map_err(|e| format!("Request creation failed: {:?}", e))?;
request
.headers()
.set("Content-Type", "application/json")
.map_err(|e| format!("Header setting failed: {:?}", e))?;
request
.headers()
.set("X-Session-Token", session_token)
.map_err(|e| format!("Header setting failed: {:?}", e))?;
let resp_value = JsFuture::from(window.fetch_with_request(&request))
.await
.map_err(|e| format!("Network request failed: {:?}", e))?;
let resp: Response = resp_value
.dyn_into()
.map_err(|e| format!("Response cast failed: {:?}", e))?;
if resp.ok() {
Ok(())
} else {
Err(format!("Failed to update preferences: {}", resp.status()))
}
}
/// Migrate preferences from LocalStorage to backend (on first login after update)
pub async fn migrate_from_local_storage(&self) -> Result<(), String> {
let session_token = LocalStorage::get::<String>("session_token")
.map_err(|_| "No session token found".to_string())?;
let mut request = UpdatePreferencesRequest {
calendar_selected_date: LocalStorage::get::<String>("calendar_selected_date").ok(),
calendar_time_increment: LocalStorage::get::<u32>("calendar_time_increment").ok().map(|i| i as i32),
calendar_view_mode: LocalStorage::get::<String>("calendar_view_mode").ok(),
calendar_theme: LocalStorage::get::<String>("calendar_theme").ok(),
calendar_colors: LocalStorage::get::<String>("calendar_colors").ok(),
};
// Only migrate if we have some preferences to migrate
if request.calendar_selected_date.is_some()
|| request.calendar_time_increment.is_some()
|| request.calendar_view_mode.is_some()
|| request.calendar_theme.is_some()
|| request.calendar_colors.is_some()
{
self.sync_preferences(&session_token, &request).await?;
// Clear old LocalStorage entries after successful migration
let _ = LocalStorage::delete("calendar_selected_date");
let _ = LocalStorage::delete("calendar_time_increment");
let _ = LocalStorage::delete("calendar_view_mode");
let _ = LocalStorage::delete("calendar_theme");
let _ = LocalStorage::delete("calendar_colors");
}
Ok(())
}
}

21
frontend/styles.css
View File

@@ -289,6 +289,27 @@ body {
cursor: not-allowed;
}
.remember-checkbox {
display: flex;
align-items: center;
gap: 0.5rem;
margin-top: 0.5rem;
}
.remember-checkbox input[type="checkbox"] {
width: auto;
margin: 0;
cursor: pointer;
}
.remember-checkbox label {
margin: 0;
font-size: 0.875rem;
color: #666;
cursor: pointer;
user-select: none;
}
.login-button, .register-button {
width: 100%;
padding: 0.75rem;