src/handlers.rs

use axum::{Extension, Json, http::StatusCode};
use serde_json::json;
use sqlx::SqlitePool;
use crate::models::{AuthPayload, PublicUser, UserRow};
use crate::auth::{hash_password, verify_password, create_jwt};

pub async fn register(
    Extension(pool): Extension,
    Json(payload): Json,
) -> Result<(StatusCode, Json), (StatusCode, String)> {
    // comprobar si ya existe
    let maybe = sqlx::query("SELECT id FROM users WHERE username = ?")
        .bind(&payload.username)
        .fetch_optional(&pool)
        .await
        .map_err(|e| (StatusCode::INTERNAL_SERVER_ERROR, e.to_string()))?;

    if maybe.is_some() {
        return Err((StatusCode::CONFLICT, "username already exists".to_string()));
    }

    let password_hash = hash_password(&payload.password).map_err(|e| (StatusCode::INTERNAL_SERVER_ERROR, e.to_string()))?;

    let res = sqlx::query("INSERT INTO users (username, password_hash) VALUES (?, ?)")
        .bind(&payload.username)
        .bind(&password_hash)
        .execute(&pool)
        .await
        .map_err(|e| (StatusCode::INTERNAL_SERVER_ERROR, e.to_string()))?;

    let user_id = res.last_insert_rowid();

    let public = PublicUser { id: user_id, username: payload.username };

    Ok((StatusCode::CREATED, Json(json!({ "user": public }))))
}

pub async fn login(
    Extension(pool): Extension,
    Json(payload): Json,
) -> Result, (StatusCode, String)> {
    let row: UserRow = sqlx::query_as("SELECT id, username, password_hash FROM users WHERE username = ?")
        .bind(&payload.username)
        .fetch_one(&pool)
        .await
        .map_err(|_| (StatusCode::UNAUTHORIZED, "invalid credentials".to_string()))?;

    let valid = verify_password(&row.password_hash, &payload.password).map_err(|e| (StatusCode::INTERNAL_SERVER_ERROR, e.to_string()))?;
    if !valid {
        return Err((StatusCode::UNAUTHORIZED, "invalid credentials".to_string()));
    }

    let secret = std::env::var("JWT_SECRET").unwrap_or_default();
    let token = create_jwt(row.id, &secret, 60 * 60 * 24).map_err(|e| (StatusCode::INTERNAL_SERVER_ERROR, e.to_string()))?;

    Ok(Json(json!({ "token": token })))
}

pub async fn me(
    Extension(pool): Extension,
    Extension(user_id): Extension,
) -> Result, (StatusCode, String)> {
    let row: UserRow = sqlx::query_as("SELECT id, username, password_hash FROM users WHERE id = ?")
        .bind(user_id)
        .fetch_one(&pool)
        .await
        .map_err(|e| (StatusCode::NOT_FOUND, e.to_string()))?;

    let public = PublicUser { id: row.id, username: row.username };
    Ok(Json(serde_json::json!({ "user": public })))
}

src/main.rs

mod db;
mod models;
mod handlers;
mod auth;

use axum::{Router, routing::{post, get}, Extension};
use tracing_subscriber::{layer::SubscriberExt, util::SubscriberInitExt};
use std::net::SocketAddr;
use sqlx::SqlitePool;

#[tokio::main]
async fn main() -> anyhow::Result<()> {
    // logger
    tracing_subscriber::registry()
        .with(tracing_subscriber::EnvFilter::from_default_env())
        .with(tracing_subscriber::fmt::layer())
        .init();

    dotenvy::dotenv().ok();
    let database_url = std::env::var("DATABASE_URL").expect("DATABASE_URL env var");

    let pool: SqlitePool = db::init_pool(&database_url).await?;

    // router
    let app = Router::new()
        .route("/register", post(handlers::register))
        .route("/login", post(handlers::login))
        // /me protegido con middleware
        .route("/me", get(handlers::me))
        .layer(Extension(pool.clone()))
        .route_layer(axum::middleware::from_fn(auth::require_auth));

    let addr = SocketAddr::from(([127, 0, 0, 1], 3000));
    tracing::info!("listening on {}", addr);
    axum::Server::bind(&addr)
        .serve(app.into_make_service())
        .await?;

    Ok(())
}

Por qué estas decisiones

• Axum: ergonomía para construir APIs async y middleware sencillo.
• SQLx + SQLite: SQLx ofrece un pool async y es fácil empezar con SQLite para demos; para producción cambia a Postgres y habilita las macros de verificación.
• Argon2: hashing seguro de contraseñas (mejor que SHA).
• JWT: permite autenticar de forma stateless. Es simple y suficiente para sesiones cortas o APIs.
• Middleware: centraliza la verificación del token y evita repetir lógica de extracción del usuario en cada handler.

Cómo probar

1. Crear .env con DATABASE_URL y JWT_SECRET.
2. Crear la tabla users (ver sección SQL).
3. cargo run
4. Usando curl o Postman:
   • POST /register {"username":"alice","password":"secret"}
   • POST /login {"username":"alice","password":"secret"} -> devuelve token
   • GET /me con header Authorization: Bearer <token>

Notas importantes y siguientes pasos

• Este ejemplo omite validaciones de entrada detalladas (longitud, caracteres) y protección contra bruteforce: añade rate limiting y validación en producción.
• En producción usa TLS, asegura JWT_SECRET con un gestor de secretos y considera tokens de refresco para sesiones largas.
• Si migras a Postgres, activa las macros de SQLx (feature "macros") para comprobación de consultas en compile-time.

Consejo avanzado: implementa rotación de claves JWT (kid en encabezado) y un endpoint de revocación que almacene tokens revocados o una versión de sesión en la DB para invalidar tokens antiguos. Atención a no almacenar secretos en el código ni devolver hashes de contraseña en respuestas JSON.