This commit is contained in:
Romulus21 committed 2026-09-20 14:50:42 +02:00
1 parent 5dcf6fed5d
commit 78582bf51e
17 files changed
+5315 -2

No files matched your search

+6
View File
@@ -1 +1,7 @@
/target /target
# Base SQLite locale (+ fichiers WAL/SHM) et variables d'environnement
*.db
*.db-shm
*.db-wal
.env
Generated
+3581
View File
File diff suppressed because it is too large. Load diff
+67
View File
@@ -3,4 +3,71 @@ name = "birthday_calendar"
version = "0.1.0" version = "0.1.0"
edition = "2024" edition = "2024"
[lib]
crate-type = ["cdylib", "rlib"]
[dependencies] [dependencies]
leptos = "0.8"
leptos_meta = "0.8"
leptos_router = "0.8"
serde = { version = "1", features = ["derive"] }
# Client (WASM)
console_error_panic_hook = { version = "0.1", optional = true }
wasm-bindgen = { version = "0.2.106", optional = true }
# Serveur uniquement
axum = { version = "0.8", optional = true }
leptos_axum = { version = "0.8", optional = true }
tokio = { version = "1", features = ["rt-multi-thread", "macros"], optional = true }
sqlx = { version = "0.8", default-features = false, features = ["runtime-tokio", "sqlite", "migrate", "macros"], optional = true }
tower-sessions = { version = "0.14", optional = true }
tower-sessions-sqlx-store = { version = "0.15", features = ["sqlite"], optional = true }
argon2 = { version = "0.5", optional = true }
time = { version = "0.3", optional = true }
[features]
hydrate = [
"leptos/hydrate",
"dep:console_error_panic_hook",
"dep:wasm-bindgen",
]
ssr = [
"dep:axum",
"dep:tokio",
"dep:leptos_axum",
"dep:sqlx",
"dep:tower-sessions",
"dep:tower-sessions-sqlx-store",
"dep:argon2",
"dep:time",
"leptos/ssr",
"leptos_meta/ssr",
"leptos_router/ssr",
]
# Profil optimisé en taille pour le bundle WASM en release
[profile.wasm-release]
inherits = "release"
opt-level = 'z'
lto = true
codegen-units = 1
panic = "abort"
[package.metadata.leptos]
output-name = "birthday_calendar"
site-root = "target/site"
site-pkg-dir = "pkg"
tailwind-input-file = "style/tailwind.css"
# Fichiers copiés tels quels à la racine du site (favicon, images…)
assets-dir = "public"
site-addr = "127.0.0.1:3000"
reload-port = 3001
browserquery = "defaults"
# Passer à "PROD" en production : active notamment le cookie de session `Secure`
env = "DEV"
bin-features = ["ssr"]
bin-default-features = false
lib-features = ["hydrate"]
lib-default-features = false
lib-profile-release = "wasm-release"
+5
View File
@@ -0,0 +1,5 @@
fn main() {
// `sqlx::migrate!()` embarque les migrations à la compilation : sans cette ligne,
// ajouter un nouveau fichier dans `migrations/` ne déclenche pas de recompilation.
println!("cargo:rerun-if-changed=migrations");
}
+7
View File
@@ -0,0 +1,7 @@
CREATE TABLE users (
id INTEGER PRIMARY KEY AUTOINCREMENT,
-- COLLATE NOCASE : "Alice" et "alice" sont le même identifiant
username TEXT NOT NULL UNIQUE COLLATE NOCASE,
password_hash TEXT NOT NULL,
created_at TEXT NOT NULL DEFAULT (datetime('now'))
);
+6
View File
@@ -0,0 +1,6 @@
-- L'identifiant de connexion devient l'adresse e-mail (stockée en minuscules par
-- l'application). Le renommage conserve les contraintes UNIQUE et COLLATE NOCASE.
--
-- Les lignes existantes ne sont pas modifiées : un ancien « nom d'utilisateur » qui
-- n'est pas une adresse e-mail valide ne permet plus de se connecter.
ALTER TABLE users RENAME COLUMN username TO email;
+15
View File
@@ -0,0 +1,15 @@
CREATE TABLE birthdays (
id INTEGER PRIMARY KEY AUTOINCREMENT,
-- Supprimer un utilisateur supprime ses anniversaires
user_id INTEGER NOT NULL REFERENCES users(id) ON DELETE CASCADE,
first_name TEXT NOT NULL,
last_name TEXT,
-- Jour, mois et année sont séparés : l'année est facultative, ce qu'une vraie
-- colonne de date ne peut pas représenter (« 12 mars » sans année).
day INTEGER NOT NULL CHECK (day BETWEEN 1 AND 31),
month INTEGER NOT NULL CHECK (month BETWEEN 1 AND 12),
year INTEGER,
created_at TEXT NOT NULL DEFAULT (datetime('now'))
);
CREATE INDEX birthdays_user_id ON birthdays (user_id);
+1
View File
@@ -0,0 +1 @@
<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 100 100"><text x="50" y="82" font-size="84" text-anchor="middle">🎂</text></svg>

After

Width:  |  Height:  |  Size: 136 B

+110
View File
@@ -0,0 +1,110 @@
use crate::{
auth::{self, Login, Logout, Register},
pages::{HomePage, LoginPage, RegisterPage},
ui::LINK,
};
use leptos::prelude::*;
use leptos_meta::{MetaTags, Stylesheet, Title, provide_meta_context};
use leptos_router::{
SsrMode, StaticSegment,
components::{A, Route, Router, Routes},
};
pub fn shell(options: LeptosOptions) -> impl IntoView {
view! {
<!DOCTYPE html>
<html lang="fr">
<head>
<meta charset="utf-8" />
<meta name="viewport" content="width=device-width, initial-scale=1" />
<link rel="icon" href="/favicon.svg" type="image/svg+xml" />
<AutoReload options=options.clone() />
<HydrationScripts options />
<MetaTags />
</head>
<body class="min-h-screen bg-zinc-50 text-zinc-900 antialiased dark:bg-zinc-950 dark:text-zinc-100">
<App />
</body>
</html>
}
}
#[component]
pub fn App() -> impl IntoView {
provide_meta_context();
let login = ServerAction::<Login>::new();
let register = ServerAction::<Register>::new();
let logout = ServerAction::<Logout>::new();
// Recharge l'utilisateur courant après chaque connexion / inscription / déconnexion.
// Ne sert qu'à l'en-tête. Les pages protégées chargent leur propre ressource : elles ne
// doivent jamais décider d'une redirection à partir de cette valeur, encore périmée
// juste après une connexion, le temps que le rechargement se termine.
let user = Resource::new(
move || {
(
login.version().get(),
register.version().get(),
logout.version().get(),
)
},
|_| auth::get_user(),
);
view! {
<Stylesheet id="leptos" href="/pkg/birthday_calendar.css" />
<Title text="Calendrier d'anniversaires" />
<Router>
<header class="flex items-center justify-between border-b border-zinc-200 bg-white px-4 py-3 dark:border-zinc-800 dark:bg-zinc-900">
<A href="/" attr:class="text-lg font-bold">
"🎂 Anniversaires"
</A>
<nav class="flex items-center gap-4 text-sm">
<Suspense>
{move || {
user.get()
.map(|user| match user {
Ok(Some(user)) => {
view! {
<span class="hidden font-semibold sm:inline">{user.email}</span>
<ActionForm action=logout>
<button type="submit" class=LINK>
"Se déconnecter"
</button>
</ActionForm>
}
.into_any()
}
_ => {
view! {
<A href="/login" attr:class=LINK>
"Connexion"
</A>
<A href="/register" attr:class=LINK>
"Inscription"
</A>
}
.into_any()
}
})
}}
</Suspense>
</nav>
</header>
<main class="mx-auto max-w-3xl px-4 py-8">
<Routes fallback=|| "Page introuvable.".into_view()>
// `Async` : le serveur attend `get_user` avant d'envoyer la réponse, ce qui permet
// un vrai « 302 vers /login » (et pas de flash de contenu) pour les visiteurs anonymes.
<Route path=StaticSegment("") view=HomePage ssr=SsrMode::Async />
<Route path=StaticSegment("login") view=move || view! { <LoginPage login /> } />
<Route
path=StaticSegment("register")
view=move || view! { <RegisterPage register /> }
/>
</Routes>
</main>
</Router>
}
}
+258
View File
@@ -0,0 +1,258 @@
//! Authentification : types partagés, règles de validation et server functions.
//!
//! Les corps des `#[server]` ne sont compilés que côté serveur ; le client
//! n'en garde que la signature (un appel HTTP généré par la macro).
use leptos::prelude::*;
use serde::{Deserialize, Serialize};
#[cfg(feature = "ssr")]
use crate::server::{self, USER_ID_KEY};
/// Utilisateur connecté, tel qu'exposé au front (jamais de hash de mot de passe ici).
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct User {
pub id: i64,
pub email: String,
}
#[cfg(feature = "ssr")]
#[derive(sqlx::FromRow)]
struct UserRow {
id: i64,
password_hash: String,
}
pub const PASSWORD_MIN: usize = 8;
/// Borne haute : Argon2 est coûteux, on refuse les mots de passe démesurés.
pub const PASSWORD_MAX: usize = 128;
/// Longueur maximale d'une adresse e-mail (RFC 5321).
pub const EMAIL_MAX: usize = 254;
/// Met l'adresse en forme canonique : sans espaces autour, en minuscules.
/// Toujours à appliquer avant de valider, chercher ou stocker une adresse.
pub fn normalize_email(email: &str) -> String {
email.trim().to_lowercase()
}
/// Validation volontairement pragmatique (pas la RFC complète) : la seule vraie
/// preuve qu'une adresse existe est d'y envoyer un message.
///
/// Attend une adresse déjà passée par [`normalize_email`].
pub fn validate_email(email: &str) -> Result<(), &'static str> {
const INVALID: &str = "Adresse e-mail invalide.";
if email.len() > EMAIL_MAX {
return Err(INVALID);
}
let Some((local, domain)) = email.split_once('@') else {
return Err(INVALID);
};
let local_ok = !local.is_empty()
&& local.len() <= 64
&& local.chars().all(|c| {
!c.is_whitespace() && !c.is_control() && !"@<>()[],;:\\\"".contains(c)
});
let domain_ok = domain.contains('.')
&& domain.split('.').all(|label| {
!label.is_empty()
&& !label.starts_with('-')
&& !label.ends_with('-')
&& label.chars().all(|c| c.is_ascii_alphanumeric() || c == '-')
});
if local_ok && domain_ok {
Ok(())
} else {
Err(INVALID)
}
}
/// Le mot de passe doit faire 8 à 128 caractères.
pub fn validate_password(password: &str) -> Result<(), &'static str> {
let len = password.chars().count();
if len < PASSWORD_MIN {
return Err("Le mot de passe doit faire au moins 8 caractères.");
}
if len > PASSWORD_MAX {
return Err("Le mot de passe doit faire au plus 128 caractères.");
}
Ok(())
}
/// Extrait le message lisible d'une erreur de server function
/// (sans le préfixe technique « error running server function: »).
pub fn error_message(error: &ServerFnError) -> String {
match error {
ServerFnError::ServerError(message) => message.clone(),
_ => "Impossible de joindre le serveur. Réessayez.".to_string(),
}
}
/// Renvoie l'utilisateur connecté, ou `None` s'il n'y a pas de session valide.
#[server]
pub async fn get_user() -> Result<Option<User>, ServerFnError> {
let session = server::session().await?;
let user_id = session
.get::<i64>(USER_ID_KEY)
.await
.map_err(server::internal_error)?;
let Some(user_id) = user_id else {
return Ok(None);
};
let row = sqlx::query_as::<_, (i64, String)>("SELECT id, email FROM users WHERE id = ?1")
.bind(user_id)
.fetch_optional(&server::pool()?)
.await
.map_err(server::internal_error)?;
match row {
Some((id, email)) => Ok(Some(User { id, email })),
None => {
// L'utilisateur a été supprimé : on invalide la session orpheline.
session.flush().await.map_err(server::internal_error)?;
Ok(None)
}
}
}
/// Crée un compte, puis connecte directement l'utilisateur.
#[server]
pub async fn register(
email: String,
password: String,
password_confirmation: String,
) -> Result<(), ServerFnError> {
let email = normalize_email(&email);
validate_email(&email).map_err(ServerFnError::new)?;
validate_password(&password).map_err(ServerFnError::new)?;
if password != password_confirmation {
return Err(ServerFnError::new("Les mots de passe ne correspondent pas."));
}
let password_hash = server::hash_password(password).await?;
let result = sqlx::query("INSERT INTO users (email, password_hash) VALUES (?1, ?2)")
.bind(&email)
.bind(&password_hash)
.execute(&server::pool()?)
.await;
let user_id = match result {
Ok(done) => done.last_insert_rowid(),
Err(sqlx::Error::Database(e)) if e.is_unique_violation() => {
return Err(ServerFnError::new("Un compte existe déjà avec cette adresse e-mail."));
}
Err(e) => return Err(server::internal_error(e)),
};
start_session(user_id).await?;
leptos_axum::redirect("/");
Ok(())
}
/// Connecte l'utilisateur si les identifiants sont corrects.
#[server]
pub async fn login(email: String, password: String) -> Result<(), ServerFnError> {
// Message volontairement identique pour « compte inconnu » et « mauvais
// mot de passe » : on ne révèle pas quels comptes existent.
const INVALID: &str = "Adresse e-mail ou mot de passe incorrect.";
if password.chars().count() > PASSWORD_MAX {
return Err(ServerFnError::new(INVALID));
}
let row = sqlx::query_as::<_, UserRow>(
"SELECT id, password_hash FROM users WHERE email = ?1",
)
.bind(normalize_email(&email))
.fetch_optional(&server::pool()?)
.await
.map_err(server::internal_error)?;
let user_id = row.as_ref().map(|r| r.id);
let stored_hash = row.map(|r| r.password_hash);
if !server::verify_password(password, stored_hash).await {
return Err(ServerFnError::new(INVALID));
}
// `verify_password` ne renvoie `true` que si l'utilisateur existe.
start_session(user_id.expect("utilisateur existant")).await?;
leptos_axum::redirect("/");
Ok(())
}
/// Déconnecte l'utilisateur et détruit sa session.
#[server]
pub async fn logout() -> Result<(), ServerFnError> {
server::session()
.await?
.flush()
.await
.map_err(server::internal_error)?;
leptos_axum::redirect("/login");
Ok(())
}
/// Ouvre une session pour `user_id`.
///
/// L'identifiant de session est renouvelé (`cycle_id`) pour empêcher les attaques
/// par fixation de session : un cookie posé avant la connexion devient inutilisable.
#[cfg(feature = "ssr")]
async fn start_session(user_id: i64) -> Result<(), ServerFnError> {
let session = server::session().await?;
session.cycle_id().await.map_err(server::internal_error)?;
session
.insert(USER_ID_KEY, user_id)
.await
.map_err(server::internal_error)?;
Ok(())
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn email_normalization() {
assert_eq!(normalize_email(" Alice@Example.COM "), "alice@example.com");
}
#[test]
fn valid_emails() {
for email in ["alice@example.com", "a.b+tag@sub.example.co", "a_b-c@ex-ample.fr"] {
assert!(validate_email(email).is_ok(), "{email} devrait être valide");
}
}
#[test]
fn invalid_emails() {
let too_long = format!("{}@example.com", "a".repeat(250));
for email in [
"",
"alice",
"alice@",
"@example.com",
"alice@example",
"a b@example.com",
"a@@example.com",
"a@b@example.com",
"alice@example..com",
"alice@.example.com",
"alice@example.com.",
"alice@-example.com",
"<x>@example.com",
"alice@exa mple.com",
too_long.as_str(),
] {
assert!(validate_email(email).is_err(), "{email} devrait être invalide");
}
}
#[test]
fn password_rules() {
assert!(validate_password("12345678").is_ok());
assert!(validate_password("1234567").is_err());
assert!(validate_password(&"a".repeat(128)).is_ok());
assert!(validate_password(&"a".repeat(129)).is_err());
}
}
+557
View File
@@ -0,0 +1,557 @@
//! Anniversaires : modèle, validation, affichage et server functions.
//!
//! Le nom de famille et l'année sont facultatifs. Tout ce qui est pur (validation,
//! formatage) est compilé des deux côtés et testé sans base de données ; seules les
//! server functions et le calcul de la prochaine occurrence sont propres au serveur.
use leptos::prelude::*;
use serde::{Deserialize, Serialize};
#[cfg(feature = "ssr")]
use crate::server;
pub const NAME_MAX: usize = 100;
/// Année de naissance minimale acceptée.
pub const YEAR_MIN: i32 = 1900;
pub const MONTHS: [&str; 12] = [
"janvier",
"février",
"mars",
"avril",
"mai",
"juin",
"juillet",
"août",
"septembre",
"octobre",
"novembre",
"décembre",
];
/// Un anniversaire, tel qu'affiché : `days_until` et `age` sont calculés par le
/// serveur au moment du chargement de la liste.
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct Birthday {
pub id: i64,
pub first_name: String,
pub last_name: Option<String>,
pub day: u8,
pub month: u8,
pub year: Option<i32>,
/// Nombre de jours avant le prochain anniversaire (0 = aujourd'hui).
pub days_until: u32,
/// Âge réel aujourd'hui, si l'année de naissance est connue.
pub age: Option<u32>,
}
impl Birthday {
pub fn full_name(&self) -> String {
match &self.last_name {
Some(last_name) => format!("{} {last_name}", self.first_name),
None => self.first_name.clone(),
}
}
}
/// Date du jour, réduite à ce dont la validation a besoin.
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub struct Today {
pub year: i32,
pub month: u8,
pub day: u8,
}
/// Saisie validée et normalisée, prête à être enregistrée.
#[derive(Debug, PartialEq, Eq)]
pub struct NewBirthday {
pub first_name: String,
pub last_name: Option<String>,
pub day: u8,
pub month: u8,
pub year: Option<i32>,
}
pub fn is_leap_year(year: i32) -> bool {
(year % 4 == 0 && year % 100 != 0) || year % 400 == 0
}
/// Nombre de jours du mois. Sans année, février compte 29 jours : on accepte
/// « 29 février » puisqu'on ne sait pas si l'année de naissance est bissextile.
pub fn days_in_month(month: u8, year: Option<i32>) -> u8 {
match month {
2 if year.is_none_or(is_leap_year) => 29,
2 => 28,
4 | 6 | 9 | 11 => 30,
_ => 31,
}
}
enum NameProblem {
TooLong,
Invalid,
}
fn name_problem(name: &str) -> Option<NameProblem> {
if name.chars().count() > NAME_MAX {
Some(NameProblem::TooLong)
} else if name.chars().any(char::is_control) {
Some(NameProblem::Invalid)
} else {
None
}
}
/// Valide et normalise la saisie du formulaire (les valeurs arrivent en texte brut).
///
/// - le prénom est obligatoire, le nom est facultatif (vide = absent) ;
/// - la date doit exister ; l'année est facultative, comprise entre 1900 et
/// aujourd'hui, et la date complète ne peut pas être dans le futur.
pub fn parse_new_birthday(
first_name: &str,
last_name: &str,
day: &str,
month: &str,
year: &str,
today: Today,
) -> Result<NewBirthday, String> {
let first_name = first_name.trim();
if first_name.is_empty() {
return Err("Le prénom est obligatoire.".into());
}
match name_problem(first_name) {
Some(NameProblem::TooLong) => {
return Err(format!("Le prénom est trop long ({NAME_MAX} caractères maximum)."));
}
Some(NameProblem::Invalid) => return Err("Le prénom contient des caractères non autorisés.".into()),
None => {}
}
let last_name = last_name.trim();
match name_problem(last_name) {
Some(NameProblem::TooLong) => {
return Err(format!("Le nom est trop long ({NAME_MAX} caractères maximum)."));
}
Some(NameProblem::Invalid) => return Err("Le nom contient des caractères non autorisés.".into()),
None => {}
}
let last_name = (!last_name.is_empty()).then(|| last_name.to_string());
let month: u8 = month
.trim()
.parse()
.ok()
.filter(|m| (1..=12).contains(m))
.ok_or("Le mois est invalide.")?;
let day: u8 = day
.trim()
.parse()
.ok()
.filter(|d| (1..=31).contains(d))
.ok_or("Le jour doit être un nombre entre 1 et 31.")?;
let year = match year.trim() {
"" => None,
text => {
let year: i32 = text.parse().map_err(|_| "L'année doit être un nombre.")?;
if !(YEAR_MIN..=today.year).contains(&year) {
return Err(format!("L'année doit être comprise entre {YEAR_MIN} et {}.", today.year));
}
Some(year)
}
};
if day > days_in_month(month, year) {
return Err("Cette date n'existe pas.".into());
}
if year == Some(today.year) && (month, day) > (today.month, today.day) {
return Err("La date de naissance ne peut pas être dans le futur.".into());
}
Ok(NewBirthday {
first_name: first_name.to_string(),
last_name,
day,
month,
year,
})
}
/// « 1er mars », « 12 mars 1990 ».
pub fn format_date(day: u8, month: u8, year: Option<i32>) -> String {
let day = if day == 1 { "1er".to_string() } else { day.to_string() };
let month = MONTHS
.get(usize::from(month).wrapping_sub(1))
.copied()
.unwrap_or("?");
match year {
Some(year) => format!("{day} {month} {year}"),
None => format!("{day} {month}"),
}
}
/// « Aujourd'hui », « Demain », « Dans 12 jours ».
pub fn format_countdown(days_until: u32) -> String {
match days_until {
0 => "Aujourd'hui".to_string(),
1 => "Demain".to_string(),
n => format!("Dans {n} jours"),
}
}
/// « 0 an », « 1 an », « 34 ans » (le singulier vaut pour 0 et 1 en français).
pub fn format_age(age: u32) -> String {
format!("{age} an{}", if age > 1 { "s" } else { "" })
}
#[cfg(feature = "ssr")]
mod schedule {
use super::is_leap_year;
use time::{Date, Month};
/// Prochaine occurrence (aujourd'hui inclus) du jour et mois donnés.
///
/// Les 29 février sont fêtés le 28 les années non bissextiles.
/// `None` si la date n'existe pas (ligne corrompue en base).
pub fn next_occurrence(today: Date, month: u8, day: u8) -> Option<Date> {
let month = Month::try_from(month).ok()?;
let on = |year: i32| {
let day = if month == Month::February && day == 29 && !is_leap_year(year) {
28
} else {
day
};
Date::from_calendar_date(year, month, day).ok()
};
let this_year = on(today.year())?;
if this_year >= today {
Some(this_year)
} else {
on(today.year() + 1)
}
}
/// Âge réel aujourd'hui d'une personne née en `birth_year`, d'après sa prochaine
/// occurrence d'anniversaire : c'est l'âge à venir, moins un tant que
/// l'anniversaire n'est pas arrivé (`days_until > 0`).
pub fn current_age(next: Date, days_until: u32, birth_year: i32) -> Option<u32> {
u32::try_from(next.year() - birth_year - i32::from(days_until > 0)).ok()
}
#[cfg(test)]
mod tests {
use super::*;
fn d(y: i32, m: u8, day: u8) -> Date {
Date::from_calendar_date(y, Month::try_from(m).unwrap(), day).unwrap()
}
#[test]
fn birthday_later_this_year() {
assert_eq!(next_occurrence(d(2026, 3, 1), 3, 12), Some(d(2026, 3, 12)));
}
#[test]
fn birthday_today_counts_as_today() {
assert_eq!(next_occurrence(d(2026, 3, 12), 3, 12), Some(d(2026, 3, 12)));
}
#[test]
fn birthday_already_passed_rolls_to_next_year() {
assert_eq!(next_occurrence(d(2026, 3, 13), 3, 12), Some(d(2027, 3, 12)));
}
#[test]
fn feb_29_is_celebrated_on_feb_28_in_common_years() {
assert_eq!(next_occurrence(d(2026, 1, 1), 2, 29), Some(d(2026, 2, 28)));
assert_eq!(next_occurrence(d(2027, 3, 1), 2, 29), Some(d(2028, 2, 29)));
}
#[test]
fn age_is_the_age_reached_at_the_last_birthday() {
let today = d(2026, 9, 19);
// Né le 12 mars 1990 : 36 ans depuis mars dernier, 37 ans en mars prochain.
let next = next_occurrence(today, 3, 12).unwrap();
assert_eq!(current_age(next, 174, 1990), Some(36));
// Né le 19 septembre 2000 : anniversaire aujourd'hui, donc 26 ans.
let next = next_occurrence(today, 9, 19).unwrap();
assert_eq!(current_age(next, 0, 2000), Some(26));
// Né le 20 septembre 2000 : demain ses 26 ans, il en a encore 25.
let next = next_occurrence(today, 9, 20).unwrap();
assert_eq!(current_age(next, 1, 2000), Some(25));
// Né le 19 septembre 2026 : nouveau-né du jour.
let next = next_occurrence(today, 9, 19).unwrap();
assert_eq!(current_age(next, 0, 2026), Some(0));
}
#[test]
fn feb_29_baby_ages_on_feb_28_in_common_years() {
// Né le 29/02/2000, le 1er mars 2026 : déjà 26 ans (fêtés le 28/02/2026).
let today = d(2026, 3, 1);
let next = next_occurrence(today, 2, 29).unwrap();
assert_eq!(current_age(next, 364, 2000), Some(26));
}
#[test]
fn corrupted_dates_do_not_panic() {
assert_eq!(next_occurrence(d(2026, 1, 1), 13, 1), None);
assert_eq!(next_occurrence(d(2026, 1, 1), 4, 31), None);
}
}
}
#[cfg(feature = "ssr")]
#[derive(sqlx::FromRow)]
struct BirthdayRow {
id: i64,
first_name: String,
last_name: Option<String>,
day: i64,
month: i64,
year: Option<i64>,
}
#[cfg(feature = "ssr")]
fn today() -> time::Date {
time::OffsetDateTime::now_utc().date()
}
/// Liste les anniversaires de l'utilisateur connecté, du plus proche au plus lointain.
#[server]
pub async fn list_birthdays() -> Result<Vec<Birthday>, ServerFnError> {
let user_id = server::require_user_id().await?;
let rows = sqlx::query_as::<_, BirthdayRow>(
"SELECT id, first_name, last_name, day, month, year FROM birthdays WHERE user_id = ?1",
)
.bind(user_id)
.fetch_all(&server::pool()?)
.await
.map_err(server::internal_error)?;
let today = today();
let mut birthdays: Vec<Birthday> = rows
.into_iter()
.filter_map(|row| {
let (day, month) = (u8::try_from(row.day).ok()?, u8::try_from(row.month).ok()?);
let year = row.year.and_then(|y| i32::try_from(y).ok());
let Some(next) = schedule::next_occurrence(today, month, day) else {
leptos::logging::error!("anniversaire {} ignoré : date invalide", row.id);
return None;
};
let days_until = u32::try_from((next - today).whole_days()).ok()?;
Some(Birthday {
id: row.id,
first_name: row.first_name,
last_name: row.last_name,
day,
month,
year,
days_until,
age: year.and_then(|y| schedule::current_age(next, days_until, y)),
})
})
.collect();
birthdays.sort_by_cached_key(|b| (b.days_until, b.first_name.to_lowercase()));
Ok(birthdays)
}
/// Ajoute un anniversaire pour l'utilisateur connecté.
#[server]
pub async fn add_birthday(
first_name: String,
last_name: String,
day: String,
month: String,
year: String,
) -> Result<(), ServerFnError> {
let user_id = server::require_user_id().await?;
let now = today();
let today = Today {
year: now.year(),
month: u8::from(now.month()),
day: now.day(),
};
let new = parse_new_birthday(&first_name, &last_name, &day, &month, &year, today)
.map_err(ServerFnError::new)?;
sqlx::query(
"INSERT INTO birthdays (user_id, first_name, last_name, day, month, year) \
VALUES (?1, ?2, ?3, ?4, ?5, ?6)",
)
.bind(user_id)
.bind(&new.first_name)
.bind(&new.last_name)
.bind(i64::from(new.day))
.bind(i64::from(new.month))
.bind(new.year)
.execute(&server::pool()?)
.await
.map_err(server::internal_error)?;
Ok(())
}
/// Supprime un anniversaire de l'utilisateur connecté.
///
/// Le `user_id` dans le `WHERE` est essentiel : sans lui, n'importe quel utilisateur
/// pourrait supprimer l'anniversaire d'un autre en devinant son identifiant.
#[server]
pub async fn delete_birthday(id: i64) -> Result<(), ServerFnError> {
let user_id = server::require_user_id().await?;
let done = sqlx::query("DELETE FROM birthdays WHERE id = ?1 AND user_id = ?2")
.bind(id)
.bind(user_id)
.execute(&server::pool()?)
.await
.map_err(server::internal_error)?;
if done.rows_affected() == 0 {
return Err(ServerFnError::new("Anniversaire introuvable."));
}
Ok(())
}
#[cfg(test)]
mod tests {
use super::*;
const TODAY: Today = Today {
year: 2026,
month: 9,
day: 19,
};
fn parse(first: &str, last: &str, day: &str, month: &str, year: &str) -> Result<NewBirthday, String> {
parse_new_birthday(first, last, day, month, year, TODAY)
}
#[test]
fn full_birthday() {
assert_eq!(
parse(" Camille ", " Dupont ", "12", "3", "1990"),
Ok(NewBirthday {
first_name: "Camille".into(),
last_name: Some("Dupont".into()),
day: 12,
month: 3,
year: Some(1990),
})
);
}
#[test]
fn last_name_and_year_are_optional() {
let b = parse("Camille", " ", "12", "3", "").unwrap();
assert_eq!(b.last_name, None);
assert_eq!(b.year, None);
}
#[test]
fn first_name_is_required() {
assert!(parse("", "Dupont", "12", "3", "").is_err());
assert!(parse(" ", "", "12", "3", "").is_err());
}
#[test]
fn names_are_bounded_and_clean() {
let long = "a".repeat(NAME_MAX + 1);
assert!(parse(&long, "", "1", "1", "").is_err());
assert!(parse("Camille", &long, "1", "1", "").is_err());
assert!(parse(&"a".repeat(NAME_MAX), "", "1", "1", "").is_ok());
assert!(parse("Ca\nmille", "", "1", "1", "").is_err());
// Apostrophes, traits d'union, accents : légitimes.
assert!(parse("Anne-Sophie", "D'Aubigné", "1", "1", "").is_ok());
}
#[test]
fn day_and_month_must_be_valid_numbers() {
assert!(parse("A", "", "0", "3", "").is_err());
assert!(parse("A", "", "32", "3", "").is_err());
assert!(parse("A", "", "abc", "3", "").is_err());
assert!(parse("A", "", "", "3", "").is_err());
assert!(parse("A", "", "12", "0", "").is_err());
assert!(parse("A", "", "12", "13", "").is_err());
assert!(parse("A", "", "12", "", "").is_err());
assert!(parse("A", "", "-1", "3", "").is_err());
}
#[test]
fn impossible_dates_are_rejected() {
assert!(parse("A", "", "31", "4", "").is_err());
assert!(parse("A", "", "30", "2", "").is_err());
assert!(parse("A", "", "29", "2", "2023").is_err());
}
#[test]
fn feb_29_depends_on_the_year() {
assert!(parse("A", "", "29", "2", "").is_ok(), "sans année : accepté");
assert!(parse("A", "", "29", "2", "2024").is_ok(), "2024 est bissextile");
assert!(parse("A", "", "29", "2", "1900").is_err(), "1900 ne l'est pas");
assert!(parse("A", "", "29", "2", "2000").is_ok(), "2000 l'est");
}
#[test]
fn year_bounds() {
assert!(parse("A", "", "1", "1", "1899").is_err());
assert!(parse("A", "", "1", "1", "1900").is_ok());
assert!(parse("A", "", "1", "1", "2026").is_ok());
assert!(parse("A", "", "1", "1", "2027").is_err());
assert!(parse("A", "", "1", "1", "abc").is_err());
}
#[test]
fn birth_date_cannot_be_in_the_future() {
assert!(parse("A", "", "19", "9", "2026").is_ok(), "aujourd'hui");
assert!(parse("A", "", "20", "9", "2026").is_err(), "demain");
assert!(parse("A", "", "1", "10", "2026").is_err());
assert!(parse("A", "", "20", "9", "").is_ok(), "sans année, pas de futur possible");
}
#[test]
fn date_formatting() {
assert_eq!(format_date(1, 3, None), "1er mars");
assert_eq!(format_date(12, 3, Some(1990)), "12 mars 1990");
assert_eq!(format_date(29, 2, None), "29 février");
assert_eq!(format_date(5, 8, None), "5 août");
}
#[test]
fn countdown_formatting() {
assert_eq!(format_countdown(0), "Aujourd'hui");
assert_eq!(format_countdown(1), "Demain");
assert_eq!(format_countdown(12), "Dans 12 jours");
}
#[test]
fn age_formatting() {
assert_eq!(format_age(0), "0 an");
assert_eq!(format_age(1), "1 an");
assert_eq!(format_age(2), "2 ans");
assert_eq!(format_age(36), "36 ans");
}
#[test]
fn month_lengths() {
assert_eq!(days_in_month(1, Some(2026)), 31);
assert_eq!(days_in_month(4, None), 30);
assert_eq!(days_in_month(2, Some(2026)), 28);
assert_eq!(days_in_month(2, Some(2024)), 29);
assert_eq!(days_in_month(2, None), 29);
}
#[test]
fn full_name() {
let mut b = Birthday {
id: 1,
first_name: "Camille".into(),
last_name: Some("Dupont".into()),
day: 1,
month: 1,
year: None,
days_until: 0,
age: None,
};
assert_eq!(b.full_name(), "Camille Dupont");
b.last_name = None;
assert_eq!(b.full_name(), "Camille");
}
}
+15
View File
@@ -0,0 +1,15 @@
pub mod app;
pub mod auth;
pub mod birthdays;
pub mod pages;
pub mod ui;
#[cfg(feature = "ssr")]
pub mod server;
#[cfg(feature = "hydrate")]
#[wasm_bindgen::prelude::wasm_bindgen]
pub fn hydrate() {
use crate::app::*;
console_error_panic_hook::set_once();
leptos::mount::hydrate_body(App);
}
+75 -2
View File
@@ -1,3 +1,76 @@
fn main() { #[cfg(feature = "ssr")]
println!("Hello, world!"); #[tokio::main]
async fn main() {
use axum::Router;
use birthday_calendar::{
app::{App, shell},
server,
};
use leptos::{logging::log, prelude::*};
use leptos_axum::{LeptosRoutes, generate_route_list};
use tower_sessions::{
Expiry, SessionManagerLayer,
cookie::{SameSite, time::Duration},
session_store::ExpiredDeletion,
};
use tower_sessions_sqlx_store::SqliteStore;
let database_url =
std::env::var("DATABASE_URL").unwrap_or_else(|_| "sqlite:birthday_calendar.db".into());
let pool = server::connect_db(&database_url)
.await
.expect("impossible d'ouvrir la base de données");
// Les sessions sont stockées en base : elles survivent à un redémarrage du serveur.
let session_store = SqliteStore::new(pool.clone());
session_store
.migrate()
.await
.expect("impossible de créer la table des sessions");
tokio::spawn(
session_store
.clone()
.continuously_delete_expired(tokio::time::Duration::from_secs(60)),
);
let conf = get_configuration(None).unwrap();
let addr = conf.leptos_options.site_addr;
let leptos_options = conf.leptos_options;
let is_prod = matches!(leptos_options.env, Env::PROD);
let session_layer = SessionManagerLayer::new(session_store)
// Cookie `Secure` (HTTPS uniquement) en production. `HttpOnly` est activé par défaut.
.with_secure(is_prod)
// `Lax` : le cookie n'est pas envoyé sur les requêtes POST venant d'un autre site (CSRF).
.with_same_site(SameSite::Lax)
.with_expiry(Expiry::OnInactivity(Duration::days(7)));
let routes = generate_route_list(App);
let app = Router::new()
.leptos_routes_with_context(
&leptos_options,
routes,
{
let pool = pool.clone();
move || provide_context(pool.clone())
},
{
let leptos_options = leptos_options.clone();
move || shell(leptos_options.clone())
},
)
.fallback(leptos_axum::file_and_error_handler(shell))
.layer(session_layer)
.with_state(leptos_options);
log!("listening on http://{}", &addr);
let listener = tokio::net::TcpListener::bind(&addr).await.unwrap();
axum::serve(listener, app.into_make_service())
.await
.unwrap();
}
#[cfg(not(feature = "ssr"))]
pub fn main() {
// Pas de `main` côté client : voir `hydrate()` dans lib.rs.
} }
+334
View File
@@ -0,0 +1,334 @@
use crate::{
auth::{self, EMAIL_MAX, Login, PASSWORD_MAX, PASSWORD_MIN, Register},
birthdays::{
self, AddBirthday, Birthday, DeleteBirthday, MONTHS, NAME_MAX, YEAR_MIN, format_age,
format_countdown, format_date,
},
ui::{Card, Field, FormError, LINK, Panel, Select, SubmitButton},
};
use leptos::{html, prelude::*};
use leptos_router::components::{A, Redirect};
/// Message d'erreur d'une action de formulaire (`login.value()`, `register.value()`), s'il y en a un.
fn error_of(
value: impl Get<Value = Option<Result<(), ServerFnError>>> + Send + Sync + 'static,
) -> impl Fn() -> Option<String> + Send + Sync + 'static {
move || {
value
.get()
.and_then(Result::err)
.map(|e| auth::error_message(&e))
}
}
/// Page d'accueil : les anniversaires de l'utilisateur, réservée aux utilisateurs connectés.
#[component]
pub fn HomePage() -> impl IntoView {
// Ressource propre à la page, rechargée à chaque visite : après une connexion, la
// navigation vers `/` a lieu avant que l'état global de l'en-tête soit à jour, et
// s'appuyer dessus renverrait à tort vers /login.
let user = Resource::new(|| (), |_| auth::get_user());
view! {
<Suspense fallback=|| view! { <p>"Chargement…"</p> }>
{move || {
user.get()
.map(|user| match user {
Ok(Some(_)) => view! { <BirthdaysPage /> }.into_any(),
_ => view! { <Redirect path="/login" /> }.into_any(),
})
}}
</Suspense>
}
}
#[component]
fn BirthdaysPage() -> impl IntoView {
let add = ServerAction::<AddBirthday>::new();
let delete = ServerAction::<DeleteBirthday>::new();
// Recharge la liste après chaque ajout ou suppression.
let list = Resource::new(
move || (add.version().get(), delete.version().get()),
|_| birthdays::list_birthdays(),
);
// Le formulaire est replié derrière le bouton « + »... sauf tant qu'il n'y a aucun
// anniversaire : le montrer d'emblée invite alors à ajouter le premier.
let open = RwSignal::new(false);
let has_entries = move || list.with(|list| matches!(list, Some(Ok(items)) if !items.is_empty()));
let is_empty = move || list.with(|list| matches!(list, Some(Ok(items)) if items.is_empty()));
let form_visible = move || open.get() || is_empty();
// Un ajout réussi garde le formulaire ouvert, pour enchaîner les saisies. Sans cela, il se
// refermerait dès que le premier anniversaire apparaît dans la liste.
Effect::new(move |_| {
if matches!(add.value().get(), Some(Ok(()))) {
open.set(true);
}
});
let first_field = NodeRef::<html::Input>::new();
// Ouvrir le formulaire à la main place le curseur dans le premier champ. Le focus est
// différé d'une frame : au moment où cet effet s'exécute, le champ est encore masqué.
Effect::new(move |_| {
if open.get() {
if let Some(input) = first_field.get() {
request_animation_frame(move || {
let _ = input.focus();
});
}
}
});
// Tout le bloc est sous un `Transition` : le serveur attend la liste avant de rendre la page,
// donc le HTML qu'il envoie (bouton « + » visible ou non, formulaire replié ou non) est
// exactement celui que le navigateur reconstruit à l'hydratation. Les enfants ne lisent
// `list` que dans des closures imbriquées : ils ne sont rendus qu'une fois, ce qui
// préserve ce qui est saisi dans le formulaire pendant les rechargements de la liste.
view! {
<Transition fallback=|| view! { <p>"Chargement…"</p> }>
<div class="flex flex-col gap-6">
<div class="flex items-center justify-between gap-4">
<h1 class="text-3xl font-bold">"Anniversaires"</h1>
// Toujours présent dans le DOM (seule sa visibilité change), pour que la
// structure soit identique côté serveur et côté client.
<div class=("hidden", move || !has_entries())>
<button
type="button"
class="flex size-10 shrink-0 items-center justify-center rounded-full bg-accent text-white shadow-sm transition hover:bg-accent-hover focus-visible:outline-2 focus-visible:outline-offset-2 focus-visible:outline-accent"
aria-controls="add-birthday"
aria-expanded=move || open.get().to_string()
aria-label=move || {
if open.get() {
"Fermer le formulaire d'ajout"
} else {
"Ajouter un anniversaire"
}
}
on:click=move |_| open.update(|open| *open = !*open)
>
// Le « + » pivote de 45° et devient un « × » quand le formulaire est ouvert.
<svg
class="size-5 transition-transform"
class=("rotate-45", move || open.get())
viewBox="0 0 24 24"
fill="none"
stroke="currentColor"
stroke-width="2.5"
stroke-linecap="round"
aria-hidden="true"
>
<path d="M12 5v14M5 12h14" />
</svg>
</button>
</div>
</div>
// Masqué par CSS plutôt que retiré du DOM : ce qui a été saisi est conservé si on
// referme puis rouvre le formulaire.
<div id="add-birthday" class=("hidden", move || !form_visible())>
<AddBirthdayForm add first_field />
</div>
{move || {
list.get()
.map(|result| match result {
Ok(items) if items.is_empty() => ().into_any(),
Ok(items) => {
view! {
<ul class="flex flex-col gap-3">
{items
.into_iter()
.map(|birthday| view! { <BirthdayItem birthday delete /> })
.collect_view()}
</ul>
}
.into_any()
}
Err(e) => {
view! { <FormError message=Some(auth::error_message(&e)) /> }
.into_any()
}
})
}}
<FormError message=error_of(delete.value()) />
</div>
</Transition>
}
}
#[component]
fn AddBirthdayForm(
add: ServerAction<AddBirthday>,
/// Premier champ du formulaire : reçoit le focus après un ajout, pour enchaîner.
first_field: NodeRef<html::Input>,
) -> impl IntoView {
let form = NodeRef::<html::Form>::new();
// Vide le formulaire quand l'ajout a réussi (`ActionForm` ne le fait pas).
Effect::new(move |_| {
if matches!(add.value().get(), Some(Ok(()))) {
if let Some(form) = form.get() {
form.reset();
}
if let Some(input) = first_field.get() {
let _ = input.focus();
}
}
});
let months = MONTHS
.iter()
.enumerate()
.map(|(i, name)| ((i + 1).to_string(), *name))
.collect::<Vec<_>>();
view! {
<Panel title="Ajouter un anniversaire">
<ActionForm action=add node_ref=form attr:class="flex flex-col gap-4">
<div class="grid grid-cols-1 gap-4 sm:grid-cols-2">
<Field
label="Prénom"
name="first_name"
autocomplete="off"
maxlength=NAME_MAX
node_ref=first_field
/>
<Field
label="Nom (facultatif)"
name="last_name"
autocomplete="off"
required=false
maxlength=NAME_MAX
/>
</div>
<div class="grid grid-cols-3 items-end gap-4">
<Field label="Jour" name="day" kind="number" min=1 max=31 />
<Select label="Mois" name="month" placeholder="Mois" options=months />
<Field
label="Année (facultatif)"
name="year"
kind="number"
required=false
min=YEAR_MIN
/>
</div>
<FormError message=error_of(add.value()) />
<div>
<SubmitButton pending=add.pending()>"Ajouter"</SubmitButton>
</div>
</ActionForm>
</Panel>
}
}
#[component]
fn BirthdayItem(birthday: Birthday, delete: ServerAction<DeleteBirthday>) -> impl IntoView {
let name = birthday.full_name();
// « 12 mars 1990 · 36 ans » : l'âge réel aujourd'hui, pas celui de la prochaine bougie.
let date = match birthday.age {
Some(age) => format!(
"{} · {}",
format_date(birthday.day, birthday.month, birthday.year),
format_age(age)
),
None => format_date(birthday.day, birthday.month, birthday.year),
};
let countdown = format_countdown(birthday.days_until);
let today = birthday.days_until == 0;
let aria_label = format!("Supprimer {name}");
view! {
<li class="flex items-center justify-between gap-4 rounded-lg border border-zinc-200 bg-white p-4 dark:border-zinc-800 dark:bg-zinc-900">
<div class="min-w-0">
<p class="truncate font-semibold">{name}</p>
<p class="text-sm text-zinc-500 dark:text-zinc-400">{date}</p>
</div>
<div class="flex shrink-0 flex-col items-end gap-1">
<p class=if today {
"text-sm font-bold text-accent"
} else {
"text-sm font-semibold"
}>{if today { format!("🎉 {countdown}") } else { countdown }}</p>
<ActionForm action=delete>
<input type="hidden" name="id" value=birthday.id />
<button
type="submit"
aria-label=aria_label
class="text-xs text-red-600 hover:underline dark:text-red-400"
>
"Supprimer"
</button>
</ActionForm>
</div>
</li>
}
}
#[component]
pub fn LoginPage(login: ServerAction<Login>) -> impl IntoView {
view! {
<Card title="Connexion">
<ActionForm action=login attr:class="flex flex-col gap-4">
<Field
label="Adresse e-mail"
name="email"
kind="email"
autocomplete="email"
maxlength=EMAIL_MAX
autofocus=true
/>
<Field
label="Mot de passe"
name="password"
kind="password"
autocomplete="current-password"
/>
<FormError message=error_of(login.value()) />
<SubmitButton pending=login.pending()>"Se connecter"</SubmitButton>
</ActionForm>
<p class="text-sm">
"Pas encore de compte ? " <A href="/register" attr:class=LINK>
"Inscription"
</A>
</p>
</Card>
}
}
#[component]
pub fn RegisterPage(register: ServerAction<Register>) -> impl IntoView {
view! {
<Card title="Inscription">
<ActionForm action=register attr:class="flex flex-col gap-4">
<Field
label="Adresse e-mail"
name="email"
kind="email"
autocomplete="email"
maxlength=EMAIL_MAX
autofocus=true
/>
<Field
label="Mot de passe"
name="password"
kind="password"
autocomplete="new-password"
minlength=PASSWORD_MIN
maxlength=PASSWORD_MAX
/>
<Field
label="Confirmer le mot de passe"
name="password_confirmation"
kind="password"
autocomplete="new-password"
minlength=PASSWORD_MIN
maxlength=PASSWORD_MAX
/>
<FormError message=error_of(register.value()) />
<SubmitButton pending=register.pending()>"Créer mon compte"</SubmitButton>
</ActionForm>
<p class="text-sm">
"Déjà inscrit ? " <A href="/login" attr:class=LINK>"Connexion"</A>
</p>
</Card>
}
}
+136
View File
@@ -0,0 +1,136 @@
//! Code exécuté uniquement côté serveur : base de données, mots de passe, session.
use argon2::{
Argon2,
password_hash::{PasswordHash, PasswordHasher, PasswordVerifier, SaltString, rand_core::OsRng},
};
use leptos::prelude::*;
use sqlx::{
SqlitePool,
sqlite::{SqliteConnectOptions, SqlitePoolOptions},
};
use std::{error::Error, fmt::Display, str::FromStr, sync::LazyLock};
use tower_sessions::Session;
/// Clé sous laquelle l'identifiant de l'utilisateur est stocké dans la session.
pub const USER_ID_KEY: &str = "user_id";
/// Ouvre le pool SQLite (en créant le fichier au besoin) et applique les migrations.
pub async fn connect_db(url: &str) -> Result<SqlitePool, Box<dyn Error>> {
let options = SqliteConnectOptions::from_str(url)?
.create_if_missing(true)
.foreign_keys(true);
let pool = SqlitePoolOptions::new()
.max_connections(5)
.connect_with(options)
.await?;
sqlx::migrate!().run(&pool).await?;
Ok(pool)
}
/// Récupère le pool fourni en contexte par `main`.
pub fn pool() -> Result<SqlitePool, ServerFnError> {
use_context::<SqlitePool>().ok_or_else(|| internal_error("SqlitePool absent du contexte"))
}
/// Récupère la session de la requête en cours.
pub async fn session() -> Result<Session, ServerFnError> {
leptos_axum::extract::<Session>().await.map_err(internal_error)
}
/// Identifiant de l'utilisateur connecté, ou une erreur s'il n'y a pas de session.
///
/// À appeler en tête de toute server function qui touche à des données personnelles,
/// puis à utiliser dans un `WHERE user_id = ?` : c'est ce qui empêche un utilisateur
/// de lire ou modifier les données d'un autre.
pub async fn require_user_id() -> Result<i64, ServerFnError> {
session()
.await?
.get::<i64>(USER_ID_KEY)
.await
.map_err(internal_error)?
.ok_or_else(|| ServerFnError::new("Vous devez être connecté."))
}
/// Journalise l'erreur réelle et renvoie au client un message générique,
/// pour ne jamais exposer de détails internes (SQL, chemins, etc.).
pub fn internal_error(error: impl Display) -> ServerFnError {
leptos::logging::error!("erreur interne : {error}");
ServerFnError::new("Une erreur interne est survenue.")
}
/// Hache un mot de passe avec Argon2id (sel aléatoire, paramètres par défaut).
///
/// Le calcul est volontairement coûteux : il est déporté sur un thread bloquant
/// pour ne pas geler le runtime async.
pub async fn hash_password(password: String) -> Result<String, ServerFnError> {
tokio::task::spawn_blocking(move || {
let salt = SaltString::generate(&mut OsRng);
Argon2::default()
.hash_password(password.as_bytes(), &salt)
.map(|hash| hash.to_string())
.map_err(|e| e.to_string())
})
.await
.map_err(internal_error)?
.map_err(internal_error)
}
/// Hash factice, vérifié quand l'utilisateur n'existe pas : le temps de réponse
/// est ainsi le même que pour un mauvais mot de passe, ce qui empêche de deviner
/// quels noms d'utilisateur existent en mesurant la latence.
static DUMMY_HASH: LazyLock<String> = LazyLock::new(|| {
let salt = SaltString::generate(&mut OsRng);
Argon2::default()
.hash_password(b"mot-de-passe-factice", &salt)
.expect("le hachage du hash factice ne peut pas échouer")
.to_string()
});
/// Vérifie un mot de passe. `stored_hash` vaut `None` si l'utilisateur n'existe pas :
/// le calcul est alors fait contre un hash factice et le résultat est toujours `false`.
pub async fn verify_password(password: String, stored_hash: Option<String>) -> bool {
tokio::task::spawn_blocking(move || {
let user_exists = stored_hash.is_some();
let hash = stored_hash.as_deref().unwrap_or(DUMMY_HASH.as_str());
let Ok(parsed) = PasswordHash::new(hash) else {
return false;
};
let valid = Argon2::default()
.verify_password(password.as_bytes(), &parsed)
.is_ok();
valid && user_exists
})
.await
.unwrap_or(false)
}
#[cfg(test)]
mod tests {
use super::*;
#[tokio::test]
async fn correct_password_is_accepted() {
let hash = hash_password("correct horse battery".into()).await.unwrap();
assert!(hash.starts_with("$argon2id$"));
assert!(verify_password("correct horse battery".into(), Some(hash)).await);
}
#[tokio::test]
async fn wrong_password_is_rejected() {
let hash = hash_password("correct horse battery".into()).await.unwrap();
assert!(!verify_password("wrong".into(), Some(hash)).await);
}
#[tokio::test]
async fn unknown_user_is_always_rejected() {
assert!(!verify_password("mot-de-passe-factice".into(), None).await);
}
#[tokio::test]
async fn same_password_gives_different_hashes() {
let a = hash_password("secret-12345".into()).await.unwrap();
let b = hash_password("secret-12345".into()).await.unwrap();
assert_ne!(a, b);
}
}
+125
View File
@@ -0,0 +1,125 @@
//! Petits composants d'interface réutilisables (Tailwind CSS).
use leptos::{html, prelude::*};
/// Lien discret aux couleurs de l'application.
pub const LINK: &str = "text-accent underline-offset-2 hover:underline";
pub const INPUT: &str = "rounded-md border border-zinc-300 bg-white px-3 py-2 text-base shadow-sm \
focus:border-accent focus:outline-none focus:ring-2 focus:ring-accent/40 \
dark:border-zinc-700 dark:bg-zinc-900";
const BUTTON: &str = "rounded-md bg-accent px-4 py-2 font-semibold text-white transition \
hover:bg-accent-hover focus-visible:outline-2 focus-visible:outline-offset-2 \
focus-visible:outline-accent disabled:cursor-wait disabled:opacity-60";
/// Carte centrée, avec un titre : conteneur des pages de connexion / inscription.
#[component]
pub fn Card(title: &'static str, children: Children) -> impl IntoView {
view! {
<div class="mx-auto flex max-w-sm flex-col gap-4 rounded-xl border border-zinc-200 bg-white p-6 shadow-sm dark:border-zinc-800 dark:bg-zinc-900">
<h1 class="text-2xl font-bold">{title}</h1>
{children()}
</div>
}
}
/// Panneau pleine largeur avec un titre de section (`<h2>`).
#[component]
pub fn Panel(title: &'static str, children: Children) -> impl IntoView {
view! {
<section class="flex flex-col gap-4 rounded-xl border border-zinc-200 bg-white p-6 shadow-sm dark:border-zinc-800 dark:bg-zinc-900">
<h2 class="text-lg font-bold">{title}</h2>
{children()}
</section>
}
}
/// Champ de formulaire : libellé + `<input>` (obligatoire par défaut).
#[component]
pub fn Field(
label: &'static str,
name: &'static str,
#[prop(default = "text")] kind: &'static str,
#[prop(optional, into)] autocomplete: Option<&'static str>,
#[prop(default = true)] required: bool,
#[prop(optional)] minlength: Option<usize>,
#[prop(optional)] maxlength: Option<usize>,
/// Bornes d'un champ `type="number"`.
#[prop(optional)] min: Option<i32>,
#[prop(optional)] max: Option<i32>,
#[prop(optional)] autofocus: bool,
/// Référence vers l'`<input>`, pour lui donner le focus depuis l'extérieur.
#[prop(optional)] node_ref: NodeRef<html::Input>,
) -> impl IntoView {
view! {
<label class="flex flex-col gap-1 text-sm font-semibold">
{label}
<input
node_ref=node_ref
class=INPUT
type=kind
name=name
autocomplete=autocomplete
minlength=minlength
maxlength=maxlength
min=min
max=max
autofocus=autofocus
required=required
/>
</label>
}
}
/// Liste déroulante obligatoire, avec une entrée vide désactivée comme invite.
#[component]
pub fn Select(
label: &'static str,
name: &'static str,
placeholder: &'static str,
/// Couples (valeur envoyée, texte affiché).
options: Vec<(String, &'static str)>,
) -> impl IntoView {
view! {
<label class="flex flex-col gap-1 text-sm font-semibold">
{label}
<select class=INPUT name=name required>
<option value="" disabled selected>
{placeholder}
</option>
{options
.into_iter()
.map(|(value, text)| view! { <option value=value>{text}</option> })
.collect_view()}
</select>
</label>
}
}
/// Bouton de validation, désactivé pendant l'envoi.
#[component]
pub fn SubmitButton(
#[prop(into)] pending: Signal<bool>,
children: Children,
) -> impl IntoView {
view! {
<button type="submit" class=BUTTON disabled=move || pending.get()>
{children()}
</button>
}
}
/// Message d'erreur (accessible : annoncé par les lecteurs d'écran).
#[component]
pub fn FormError(#[prop(into)] message: Signal<Option<String>>) -> impl IntoView {
move || {
message.get().map(|message| {
view! {
<p class="text-sm text-red-600 dark:text-red-400" role="alert">
{message}
</p>
}
})
}
}
+17
View File
@@ -0,0 +1,17 @@
@import "tailwindcss";
/* Tailwind v4 détecte automatiquement les classes dans le code, mais on déclare
la source explicitement : les vues Leptos vivent dans le dossier `src`. */
@source "../src";
@theme {
--color-accent: #d6336c;
--color-accent-hover: #b82a5c;
}
@layer base {
/* Contrôles de formulaire, barres de défilement, etc. suivent le thème du système. */
:root {
color-scheme: light dark;
}
}