Backend stuff done for the verification

rust-server/src/db/queries.rs

@@ -21,7 +21,7 @@ pub async fn find_user_by_username(db: &PgPool, username: &str) -> Result<Option
 
 #[allow(dead_code)]
 pub async fn find_user_by_id(db: &PgPool, id: Uuid) -> Result<Option<PgRow>, AppError> {
-    sqlx::query("SELECT id FROM users WHERE id = $1")
+    sqlx::query("SELECT id, email FROM users WHERE id = $1")
         .bind(id)
         .fetch_optional(db)
         .await

rust-server/src/errors.rs

@@ -12,14 +12,16 @@ use crate::db::connect::DbError;
 #[derive(Debug)]
 #[allow(dead_code)]
 pub enum AppError {
-    NotFound(String),
-    Internal(String),
-    Database(String),
-    BadRequest(String),
-    Json(JsonRejection),
-    Validation(ValidationErrors),
-    Sql(sqlx::Error),
-    Conflict(String),
+    NotFound(String),             // 404
+    Internal(String),             // 500
+    Database(String),             // 503
+    BadRequest(String),           // 400
+    Json(JsonRejection),          // 400 with detailed JSON error
+    Validation(ValidationErrors), // 400 with validation error details
+    Sql(sqlx::Error), // 404 for RowNotFound, 409 for unique constraint violation, 500 for others
+    Conflict(String), // 409
+    Gone(String),     // 410
+    TooManyRequests(String), // 429
 }
 
 #[derive(Serialize)]
@@ -30,25 +32,40 @@ struct ErrorBody {
 
 #[allow(dead_code)]
 impl AppError {
+    // 404 Not Found
     pub fn not_found(message: impl Into<String>) -> Self {
         Self::NotFound(message.into())
     }
 
+    // 500 Internal Server Error
     pub fn internal(message: impl Into<String>) -> Self {
         Self::Internal(message.into())
     }
 
+    // 503 Service Unavailable (for database errors)
     pub fn database(message: impl Into<String>) -> Self {
         Self::Database(message.into())
     }
 
+    // 400 Bad Request
     pub fn bad_request(message: impl Into<String>) -> Self {
         Self::BadRequest(message.into())
     }
 
+    // 409 Conflict
     pub fn conflict(message: impl Into<String>) -> Self {
         Self::Conflict(message.into())
     }
+
+    // 410 Gone
+    pub fn gone(message: impl Into<String>) -> Self {
+        Self::Gone(message.into())
+    }
+
+    // 429 Too Many Requests
+    pub fn too_many_requests(message: impl Into<String>) -> Self {
+        Self::TooManyRequests(message.into())
+    }
 }
 
 impl IntoResponse for AppError {
@@ -58,6 +75,8 @@ impl IntoResponse for AppError {
             AppError::Internal(message) => (StatusCode::INTERNAL_SERVER_ERROR, message),
             AppError::Database(message) => (StatusCode::SERVICE_UNAVAILABLE, message),
             AppError::BadRequest(message) => (StatusCode::BAD_REQUEST, message),
+            AppError::Gone(message) => (StatusCode::GONE, message),
+            AppError::TooManyRequests(message) => (StatusCode::TOO_MANY_REQUESTS, message),
             AppError::Json(rejection) => {
                 let message = match rejection {
                     JsonRejection::JsonDataError(e) => format!("Invalid JSON: {}", e),

rust-server/src/features/auth/handlers.rs

@@ -1,7 +1,9 @@
-use crate::db::queries::{find_token_by_value, find_user_by_email, find_user_by_username};
-use crate::features::auth::queries::{delete_user, verify_user};
+use crate::db::queries::{
+    find_token_by_value, find_user_by_email, find_user_by_id, find_user_by_username,
+};
+use crate::features::auth::queries::{delete_user, update_verification_token, verify_user};
 use crate::features::auth::service::new_user;
-use crate::features::auth::types::{AvailabilityQuery, VerifyQuery};
+use crate::features::auth::types::{AvailabilityQuery, ResendTokenData, VerifyQuery};
 use crate::state::AppState;
 use crate::utils::api_response::ApiResponse;
 use crate::utils::password::hash_password;
@@ -142,14 +144,53 @@ pub async fn verify_account(
     let expires_at: DateTime<Utc> = row.get("expires_at");
 
     if Utc::now() > expires_at {
-        return Err(AppError::bad_request("Token has expired"));
+        return Err(AppError::gone("Token has expired"));
     }
 
     verify_user(db, user_id).await?;
 
     Ok(ApiResponse::ok("Email verified successfully", None))
 }
 
+// ----------------------
+// /api/auth/verify
+// POST
+// Update verification token (for resending verification email)
+// ----------------------
+pub async fn resend_token(
+    State(state): State<AppState>,
+    Query(params): Query<ResendTokenData>,
+) -> Result<ApiResponse<()>, AppError> {
+    let token = &params.token;
+
+    let db = state.db()?;
+    let result = find_token_by_value(db, token)
+        .await?
+        .ok_or_else(|| AppError::not_found("Token not found"));
+
+    let user = find_user_by_id(db, result?.get("user_id"))
+        .await?
+        .ok_or_else(|| AppError::not_found("User not found"))?;
+    eprint!("RESULT: {:#?}", user);
+
+    let new_token = update_verification_token(db, user.get("id")).await?;
+
+    if !state.config.app_env.is_test()
+        && let Err(email_err) = state
+            .email
+            .send_verification_email(user.get("email"), &new_token)
+            .await
+    {
+        tracing::error!("Failed to send verification email: {:#?}", email_err);
+        return Err(email_err);
+    }
+
+    Ok(ApiResponse::ok(
+        "Verification email resent. Check your inbox.",
+        None,
+    ))
+}
+
 // -----------------
 // Validate data
 // -----------------

rust-server/src/features/auth/queries.rs

@@ -4,7 +4,7 @@ use sqlx::{Executor, Postgres, types::Uuid};
 
 use crate::errors::AppError;
 
-// Create user - POST
+// Create user - CREATE
 pub async fn create_user<'e, E>(
     db: E,
     email: &str,
@@ -27,7 +27,7 @@ where
     Ok(row)
 }
 
-// Create verification token - POST
+// Create verification token - CREATE
 pub async fn create_verification_token<'e, E>(
     db: E,
     user_id: Uuid,
@@ -75,3 +75,22 @@ where
 
     Ok(())
 }
+
+// Update token - UPDATE (for resending verification email)
+pub async fn update_verification_token<'e, E>(db: E, user_id: Uuid) -> Result<String, AppError>
+where
+    E: Executor<'e, Database = Postgres>,
+{
+    let new_token = Uuid::new_v4().to_string();
+    let new_expires_at = Utc::now() + chrono::Duration::hours(24);
+
+    sqlx::query("UPDATE tokens SET token = $1, expires_at = $2 WHERE user_id = $3")
+        .bind(&new_token)
+        .bind(new_expires_at)
+        .bind(user_id)
+        .execute(db)
+        .await
+        .map_err(AppError::Sql)?;
+
+    Ok(new_token)
+}

rust-server/src/features/auth/routes.rs

@@ -1,6 +1,6 @@
 use super::handlers::register_user;
 use crate::{
-    features::auth::handlers::{check_availability, verify_account},
+    features::auth::handlers::{check_availability, resend_token, verify_account},
     state::AppState,
 };
 use axum::{
@@ -12,5 +12,5 @@ pub fn auth_router() -> Router<AppState> {
     Router::new()
         .route("/register", post(register_user))
         .route("/available", get(check_availability))
-        .route("/verify", get(verify_account))
+        .route("/verify", get(verify_account).post(resend_token))
 }

rust-server/src/features/auth/types.rs

@@ -28,6 +28,14 @@ pub struct RegisterData {
     pub password: String,
 }
 
+// -----------------------
+// Resend token data
+// -----------------------
+#[derive(Deserialize)]
+pub struct ResendTokenData {
+    pub token: String,
+}
+
 // -----------------------
 // Queries (params)
 // -----------------------
@@ -38,7 +46,6 @@ pub struct AvailabilityQuery {
 }
 
 #[derive(Deserialize)]
-
 pub struct VerifyQuery {
     pub token: Option<String>,
 }