what2watch/src/users.rs

use argon2::{
    password_hash::{rand_core::OsRng, PasswordHash, PasswordHasher, PasswordVerifier, SaltString},
    Argon2,
};
use sqlx::{error::DatabaseError, Sqlite, SqlitePool};
use tracing::log::log;
use uuid::Uuid;

const CREATE_QUERY: &str =
    "insert into witches (id, username, displayname, email, pwhash) values ($1, $2, $3, $4, $5)";

pub struct User {
    id: Uuid,
    username: String,
    displayname: Option<String>,
    email: Option<String>,
}

#[derive(Debug, Clone, sqlx::FromRow, sqlx::Encode)]
struct DbUser {
    id: Uuid,
    username: String,
    displayname: Option<String>,
    email: Option<String>,
    last_seen: Option<u64>,
    pwhash: String,
}

impl From<DbUser> for User {
    fn from(dbu: DbUser) -> Self {
        User {
            id: dbu.id,
            username: dbu.username,
            displayname: dbu.displayname,
            email: dbu.email,
        }
    }
}

pub async fn create_user(
    username: &str,
    displayname: &Option<String>,
    email: &Option<String>,
    password: &[u8],
    pool: &SqlitePool,
) -> Result<User, CreateUserError> {
    // Argon2 with default params (Argon2id v19)
    let argon2 = Argon2::default();

    let salt = SaltString::generate(&mut OsRng);
    let pwhash = argon2
        .hash_password(password, &salt)
        .unwrap() // safe to unwrap, we know the salt is valid
        .to_string();

    let id = Uuid::new_v4();
    let id_bytes = sqlx::types::Uuid::from_u128(id.as_u128());
    let res = sqlx::query(CREATE_QUERY)
        .bind(id_bytes)
        .bind(username)
        .bind(displayname)
        .bind(email)
        .bind(pwhash)
        .execute(pool)
        .await;

    match res {
        Ok(_) => {
            let user = User {
                id,
                username: username.to_string(),
                displayname: displayname.to_owned(),
                email: email.to_owned(),
            };
            Ok(user)
        }
        Err(sqlx::Error::Database(db)) => {
            if let Some(exit) = db.code() {
                if exit.parse().unwrap_or(0) == 2067u32 {
                    Err(CreateUserErrorKind::AlreadyExists.into())
                } else {
                    Err(CreateUserErrorKind::Unknown.into())
                }
            } else {
                Err(CreateUserErrorKind::Unknown.into())
            }
        }
        _ => unreachable!(),
    }
}

#[Error(desc = "Could not create user.")]
#[non_exhaustive]
pub struct CreateUserError(#[from] CreateUserErrorKind);

#[Error]
#[non_exhaustive]
pub enum CreateUserErrorKind {
    AlreadyExists,
    #[error(
        desc = "Usernames must be less than 20 characters and contain only ascii letters, numbers, and dashes."
    )]
    BadUsername,
    PasswordMismatch,
    MissingFields,
    Unknown,
}