refactor: html-router builder pattern and structure

crates/html-router/src/routes/auth/mod.rs

@@ -0,0 +1,24 @@
+pub mod signin;
+pub mod signout;
+pub mod signup;
+
+use axum::{extract::FromRef, routing::get, Router};
+use signin::{authenticate_user, show_signin_form};
+use signout::sign_out_user;
+use signup::{process_signup_and_show_verification, show_signup_form};
+
+use crate::html_state::HtmlState;
+
+pub fn router<S>() -> Router<S>
+where
+    S: Clone + Send + Sync + 'static,
+    HtmlState: FromRef<S>,
+{
+    Router::new()
+        .route("/signout", get(sign_out_user))
+        .route("/signin", get(show_signin_form).post(authenticate_user))
+        .route(
+            "/signup",
+            get(show_signup_form).post(process_signup_and_show_verification),
+        )
+}

crates/html-router/src/routes/auth/signin.rs

@@ -0,0 +1,59 @@
+use axum::{
+    extract::State,
+    response::{Html, IntoResponse},
+    Form,
+};
+use axum_htmx::HxBoosted;
+use serde::{Deserialize, Serialize};
+
+use crate::{
+    html_state::HtmlState,
+    middlewares::response_middleware::{HtmlError, TemplateResponse},
+    AuthSessionType,
+};
+use common::storage::types::user::User;
+
+#[derive(Deserialize, Serialize)]
+pub struct SignupParams {
+    pub email: String,
+    pub password: String,
+    pub remember_me: Option<String>,
+}
+
+pub async fn show_signin_form(
+    auth: AuthSessionType,
+    HxBoosted(boosted): HxBoosted,
+) -> Result<impl IntoResponse, HtmlError> {
+    if auth.is_authenticated() {
+        return Ok(TemplateResponse::redirect("/"));
+    }
+    match boosted {
+        true => Ok(TemplateResponse::new_partial(
+            "auth/signin_form.html",
+            "body",
+            {},
+        )),
+        false => Ok(TemplateResponse::new_template("auth/signin_form.html", {})),
+    }
+}
+
+pub async fn authenticate_user(
+    State(state): State<HtmlState>,
+    auth: AuthSessionType,
+    Form(form): Form<SignupParams>,
+) -> Result<impl IntoResponse, HtmlError> {
+    let user = match User::authenticate(&form.email, &form.password, &state.db).await {
+        Ok(user) => user,
+        Err(_) => {
+            return Ok(Html("<p>Incorrect email or password </p>").into_response());
+        }
+    };
+
+    auth.login_user(user.id);
+
+    if form.remember_me.is_some_and(|string| string == *"on") {
+        auth.remember_user(true);
+    }
+
+    Ok(TemplateResponse::redirect("/").into_response())
+}

crates/html-router/src/routes/auth/signout.rs

@@ -0,0 +1,16 @@
+use axum::response::IntoResponse;
+
+use crate::{
+    middlewares::response_middleware::{HtmlError, TemplateResponse},
+    AuthSessionType,
+};
+
+pub async fn sign_out_user(auth: AuthSessionType) -> Result<impl IntoResponse, HtmlError> {
+    if !auth.is_authenticated() {
+        return Ok(TemplateResponse::redirect("/"));
+    }
+
+    auth.logout_user();
+
+    Ok(TemplateResponse::redirect("/"))
+}

crates/html-router/src/routes/auth/signup.rs

@@ -0,0 +1,58 @@
+use axum::{
+    extract::State,
+    response::{Html, IntoResponse},
+    Form,
+};
+use axum_htmx::HxBoosted;
+use serde::{Deserialize, Serialize};
+
+use common::storage::types::user::User;
+
+use crate::{
+    html_state::HtmlState,
+    middlewares::response_middleware::{HtmlError, TemplateResponse},
+    AuthSessionType,
+};
+
+#[derive(Deserialize, Serialize)]
+pub struct SignupParams {
+    pub email: String,
+    pub password: String,
+    pub timezone: String,
+}
+
+pub async fn show_signup_form(
+    auth: AuthSessionType,
+    HxBoosted(boosted): HxBoosted,
+) -> Result<impl IntoResponse, HtmlError> {
+    if auth.is_authenticated() {
+        return Ok(TemplateResponse::redirect("/"));
+    }
+
+    match boosted {
+        true => Ok(TemplateResponse::new_partial(
+            "auth/signup_form.html",
+            "body",
+            {},
+        )),
+        false => Ok(TemplateResponse::new_template("auth/signup_form.html", {})),
+    }
+}
+
+pub async fn process_signup_and_show_verification(
+    State(state): State<HtmlState>,
+    auth: AuthSessionType,
+    Form(form): Form<SignupParams>,
+) -> Result<impl IntoResponse, HtmlError> {
+    let user = match User::create_new(form.email, form.password, &state.db, form.timezone).await {
+        Ok(user) => user,
+        Err(e) => {
+            tracing::error!("{:?}", e);
+            return Ok(Html(format!("<p>{}</p>", e)).into_response());
+        }
+    };
+
+    auth.login_user(user.id);
+
+    Ok(TemplateResponse::redirect("/").into_response())
+}