Ajoute l'authentification et le partage de listes

- Inscription / connexion par email + mot de passe (argon2), prénom ou
  pseudo enregistré ; session par cookie HttpOnly, jeton haché en base.
- Listes privées par propriétaire, partageables par email ; les membres
  peuvent gérer les articles et quitter la liste.
- Contrôle d'accès dans chaque server function.
- Suggestions propres à chaque utilisateur.
- Avatar avec initiales et feuille de compte (déconnexion).
- La page 404 reçoit le pool SQLite.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
Romulus21andClaude Opus 5.5 committed 2026-10-09 12:47:09 +02:00
1 parent 9536cf0dbe
commit cbda09ed40
12 files changed
+1083 -60

No files matched your search

+205 -18
View File
@@ -1,13 +1,18 @@
use leptos::prelude::*;
use leptos::server_fn::codec::Json;
use crate::model::{Item, ItemInput, ListColor, ShoppingList, Suggestion};
use crate::model::{Item, ItemInput, ListColor, Member, ShoppingList, Suggestion, User};
pub const NOT_LOGGED_IN: &str = "Session expirée, reconnecte-toi.";
#[cfg(feature = "ssr")]
mod server {
use leptos::prelude::*;
use sqlx::SqlitePool;
use crate::db::Role;
use crate::model::User;
pub fn pool() -> Result<SqlitePool, ServerFnError> {
use_context::<SqlitePool>().ok_or_else(|| ServerFnError::new("database pool missing"))
}
@@ -17,75 +22,257 @@ mod server {
ServerFnError::new("Erreur de base de données")
}
pub fn clean_name(name: &str) -> Result<String, ServerFnError> {
pub async fn require_user(pool: &SqlitePool) -> Result<User, ServerFnError> {
crate::auth::current_user(pool)
.await
.map_err(db_err)?
.ok_or_else(|| ServerFnError::new(super::NOT_LOGGED_IN))
}
fn not_found() -> ServerFnError {
ServerFnError::new("Liste introuvable.")
}
/// Fails unless the user owns the list or it is shared with them.
pub async fn require_list(pool: &SqlitePool, user: &User, list_id: i64) -> Result<Role, ServerFnError> {
crate::db::list_role(pool, user.id, list_id)
.await
.map_err(db_err)?
.ok_or_else(not_found)
}
pub async fn require_owner(pool: &SqlitePool, user: &User, list_id: i64) -> Result<(), ServerFnError> {
match require_list(pool, user, list_id).await? {
Role::Owner => Ok(()),
Role::Member => Err(ServerFnError::new("Seul le propriétaire de la liste peut faire ça.")),
}
}
/// Fails unless the item belongs to a list the user can access.
pub async fn require_item(pool: &SqlitePool, user: &User, item_id: i64) -> Result<(), ServerFnError> {
let list_id = crate::db::item_list_id(pool, item_id)
.await
.map_err(db_err)?
.ok_or_else(|| ServerFnError::new("Article introuvable."))?;
require_list(pool, user, list_id).await.map(|_| ())
}
pub fn clean_name(name: &str, max: usize) -> Result<String, ServerFnError> {
let name = name.trim();
if name.is_empty() || name.chars().count() > 60 {
return Err(ServerFnError::new("Le nom doit faire entre 1 et 60 caractères"));
if name.is_empty() || name.chars().count() > max {
return Err(ServerFnError::new(format!("Le nom doit faire entre 1 et {max} caractères.")));
}
Ok(name.to_owned())
}
pub fn clean_email(email: &str) -> Result<String, ServerFnError> {
let email = email.trim().to_lowercase();
let valid = email.len() <= 254
&& email
.split_once('@')
.is_some_and(|(local, domain)| !local.is_empty() && domain.contains('.') && !domain.starts_with('.'));
if !valid {
return Err(ServerFnError::new("Adresse email invalide."));
}
Ok(email)
}
pub async fn blocking<T: Send + 'static>(f: impl FnOnce() -> T + Send + 'static) -> Result<T, ServerFnError> {
tokio::task::spawn_blocking(f)
.await
.map_err(|_| ServerFnError::new("Erreur interne"))
}
}
// --- Account ----------------------------------------------------------------
#[server]
pub async fn get_me() -> Result<Option<User>, ServerFnError> {
use server::*;
crate::auth::current_user(&pool()?).await.map_err(db_err)
}
#[server]
pub async fn register(name: String, email: String, password: String) -> Result<(), ServerFnError> {
use server::*;
let pool = pool()?;
let name = clean_name(&name, 40)?;
let email = clean_email(&email)?;
if !(8..=128).contains(&password.chars().count()) {
return Err(ServerFnError::new("Le mot de passe doit faire au moins 8 caractères."));
}
let hash = blocking(move || crate::auth::hash_password(&password))
.await?
.map_err(|_| ServerFnError::new("Erreur interne"))?;
let user_id = match crate::db::register(&pool, &email, &name, &hash).await {
Ok(id) => id,
Err(sqlx::Error::Database(err)) if err.is_unique_violation() => {
return Err(ServerFnError::new("Un compte existe déjà avec cet email."));
}
Err(err) => return Err(db_err(err)),
};
crate::auth::start_session(&pool, user_id).await.map_err(db_err)?;
leptos_axum::redirect("/");
Ok(())
}
#[server]
pub async fn login(email: String, password: String) -> Result<(), ServerFnError> {
use server::*;
let pool = pool()?;
let found = crate::db::user_by_email(&pool, email.trim()).await.map_err(db_err)?;
let (user, hash) = match found {
Some((user, hash)) => (Some(user), hash),
None => (None, crate::auth::dummy_hash().to_owned()),
};
let valid = blocking(move || crate::auth::verify_password(&password, &hash)).await?;
let Some(user) = user.filter(|_| valid) else {
return Err(ServerFnError::new("Email ou mot de passe incorrect."));
};
crate::auth::start_session(&pool, user.id).await.map_err(db_err)?;
leptos_axum::redirect("/");
Ok(())
}
#[server]
pub async fn logout() -> Result<(), ServerFnError> {
use server::*;
crate::auth::end_session(&pool()?).await.map_err(db_err)?;
leptos_axum::redirect("/connexion");
Ok(())
}
// --- Lists ------------------------------------------------------------------
#[server]
pub async fn get_lists() -> Result<Vec<ShoppingList>, ServerFnError> {
use server::*;
crate::db::lists(&pool()?).await.map_err(db_err)
let pool = pool()?;
let user = require_user(&pool).await?;
crate::db::lists(&pool, user.id).await.map_err(db_err)
}
#[server]
pub async fn create_list(name: String, color: ListColor) -> Result<i64, ServerFnError> {
use server::*;
let name = clean_name(&name)?;
crate::db::create_list(&pool()?, &name, color).await.map_err(db_err)
let pool = pool()?;
let user = require_user(&pool).await?;
let name = clean_name(&name, 60)?;
crate::db::create_list(&pool, user.id, &name, color).await.map_err(db_err)
}
#[server]
pub async fn rename_list(id: i64, name: String) -> Result<(), ServerFnError> {
use server::*;
let name = clean_name(&name)?;
crate::db::rename_list(&pool()?, id, &name).await.map_err(db_err)
let pool = pool()?;
let user = require_user(&pool).await?;
require_owner(&pool, &user, id).await?;
let name = clean_name(&name, 60)?;
crate::db::rename_list(&pool, id, &name).await.map_err(db_err)
}
#[server]
pub async fn delete_list(id: i64) -> Result<(), ServerFnError> {
use server::*;
crate::db::delete_list(&pool()?, id).await.map_err(db_err)
let pool = pool()?;
let user = require_user(&pool).await?;
require_owner(&pool, &user, id).await?;
crate::db::delete_list(&pool, id).await.map_err(db_err)
}
#[server]
pub async fn get_members(list_id: i64) -> Result<Vec<Member>, ServerFnError> {
use server::*;
let pool = pool()?;
let user = require_user(&pool).await?;
require_list(&pool, &user, list_id).await?;
crate::db::members(&pool, list_id).await.map_err(db_err)
}
#[server]
pub async fn share_list(list_id: i64, email: String) -> Result<(), ServerFnError> {
use server::*;
let pool = pool()?;
let user = require_user(&pool).await?;
require_owner(&pool, &user, list_id).await?;
let email = clean_email(&email)?;
let (friend, _) = crate::db::user_by_email(&pool, &email)
.await
.map_err(db_err)?
.ok_or_else(|| ServerFnError::new("Aucun compte avec cet email."))?;
if friend.id == user.id {
return Err(ServerFnError::new("Tu es déjà propriétaire de cette liste."));
}
crate::db::add_member(&pool, list_id, friend.id).await.map_err(db_err)
}
/// The owner removes someone, or a member leaves (`user_id` = themself).
#[server]
pub async fn remove_member(list_id: i64, user_id: i64) -> Result<(), ServerFnError> {
use server::*;
let pool = pool()?;
let user = require_user(&pool).await?;
if user_id != user.id {
require_owner(&pool, &user, list_id).await?;
}
crate::db::remove_member(&pool, list_id, user_id).await.map_err(db_err)
}
// --- Items ------------------------------------------------------------------
#[server]
pub async fn get_items(list_id: i64) -> Result<Vec<Item>, ServerFnError> {
use server::*;
crate::db::items(&pool()?, list_id).await.map_err(db_err)
let pool = pool()?;
let user = require_user(&pool).await?;
require_list(&pool, &user, list_id).await?;
crate::db::items(&pool, list_id).await.map_err(db_err)
}
#[server(input = Json)]
pub async fn add_item(list_id: i64, input: ItemInput) -> Result<i64, ServerFnError> {
use server::*;
let input = ItemInput { name: clean_name(&input.name)?, ..input };
crate::db::add_item(&pool()?, list_id, &input).await.map_err(db_err)
let pool = pool()?;
let user = require_user(&pool).await?;
require_list(&pool, &user, list_id).await?;
let input = ItemInput { name: clean_name(&input.name, 60)?, ..input };
crate::db::add_item(&pool, user.id, list_id, &input).await.map_err(db_err)
}
#[server(input = Json)]
pub async fn update_item(id: i64, input: ItemInput) -> Result<(), ServerFnError> {
use server::*;
let input = ItemInput { name: clean_name(&input.name)?, ..input };
crate::db::update_item(&pool()?, id, &input).await.map_err(db_err)
let pool = pool()?;
let user = require_user(&pool).await?;
require_item(&pool, &user, id).await?;
let input = ItemInput { name: clean_name(&input.name, 60)?, ..input };
crate::db::update_item(&pool, id, &input).await.map_err(db_err)
}
#[server]
pub async fn delete_item(id: i64) -> Result<(), ServerFnError> {
use server::*;
crate::db::delete_item(&pool()?, id).await.map_err(db_err)
let pool = pool()?;
let user = require_user(&pool).await?;
require_item(&pool, &user, id).await?;
crate::db::delete_item(&pool, id).await.map_err(db_err)
}
#[server]
pub async fn set_checked(id: i64, checked: bool) -> Result<(), ServerFnError> {
use server::*;
crate::db::set_checked(&pool()?, id, checked).await.map_err(db_err)
let pool = pool()?;
let user = require_user(&pool).await?;
require_item(&pool, &user, id).await?;
crate::db::set_checked(&pool, id, checked).await.map_err(db_err)
}
#[server]
pub async fn get_suggestions(list_id: i64) -> Result<Vec<Suggestion>, ServerFnError> {
use server::*;
crate::db::suggestions(&pool()?, list_id, 3).await.map_err(db_err)
let pool = pool()?;
let user = require_user(&pool).await?;
require_list(&pool, &user, list_id).await?;
crate::db::suggestions(&pool, user.id, list_id, 3).await.map_err(db_err)
}