120 lines
3.5 KiB
Rust
120 lines
3.5 KiB
Rust
use crate::db::PgPool;
|
|
use async_trait::async_trait;
|
|
use chrono::{DateTime, Utc};
|
|
use domain::{
|
|
errors::DomainError,
|
|
ports::UserRepository,
|
|
value_objects::{Email, PasswordHash, SystemId},
|
|
};
|
|
use uuid::Uuid;
|
|
|
|
#[derive(sqlx::FromRow)]
|
|
struct UserRow {
|
|
id: Uuid,
|
|
username: String,
|
|
email: String,
|
|
password_hash: String,
|
|
created_at: DateTime<Utc>,
|
|
}
|
|
|
|
impl TryFrom<UserRow> for domain::entities::User {
|
|
type Error = DomainError;
|
|
fn try_from(r: UserRow) -> Result<Self, Self::Error> {
|
|
Ok(Self {
|
|
id: SystemId::from_uuid(r.id),
|
|
username: r.username,
|
|
email: Email::new(r.email)?,
|
|
password_hash: PasswordHash::from_hash(r.password_hash),
|
|
created_at: r.created_at,
|
|
})
|
|
}
|
|
}
|
|
|
|
pub struct PostgresUserRepository {
|
|
pool: PgPool,
|
|
}
|
|
|
|
impl PostgresUserRepository {
|
|
pub fn new(pool: PgPool) -> Self {
|
|
Self { pool }
|
|
}
|
|
}
|
|
|
|
#[async_trait]
|
|
impl UserRepository for PostgresUserRepository {
|
|
async fn find_by_id(
|
|
&self,
|
|
id: &SystemId,
|
|
) -> Result<Option<domain::entities::User>, DomainError> {
|
|
let row = sqlx::query_as::<_, UserRow>(
|
|
"SELECT id, username, email, password_hash, created_at FROM users WHERE id = $1",
|
|
)
|
|
.bind(*id.as_uuid())
|
|
.fetch_optional(&self.pool)
|
|
.await
|
|
.map_err(|e| DomainError::Internal(e.to_string()))?;
|
|
|
|
row.map(TryInto::try_into).transpose()
|
|
}
|
|
|
|
async fn find_by_email(
|
|
&self,
|
|
email: &Email,
|
|
) -> Result<Option<domain::entities::User>, DomainError> {
|
|
let row = sqlx::query_as::<_, UserRow>(
|
|
"SELECT id, username, email, password_hash, created_at FROM users WHERE email = $1",
|
|
)
|
|
.bind(email.as_str())
|
|
.fetch_optional(&self.pool)
|
|
.await
|
|
.map_err(|e| DomainError::Internal(e.to_string()))?;
|
|
|
|
row.map(TryInto::try_into).transpose()
|
|
}
|
|
|
|
async fn find_by_username(
|
|
&self,
|
|
username: &str,
|
|
) -> Result<Option<domain::entities::User>, DomainError> {
|
|
let row = sqlx::query_as::<_, UserRow>(
|
|
"SELECT id, username, email, password_hash, created_at FROM users WHERE username = $1",
|
|
)
|
|
.bind(username)
|
|
.fetch_optional(&self.pool)
|
|
.await
|
|
.map_err(|e| DomainError::Internal(e.to_string()))?;
|
|
|
|
row.map(TryInto::try_into).transpose()
|
|
}
|
|
|
|
async fn save(&self, user: &domain::entities::User) -> Result<(), DomainError> {
|
|
sqlx::query_as::<_, UserRow>(
|
|
"INSERT INTO users (id, username, email, password_hash, created_at)
|
|
VALUES ($1, $2, $3, $4, $5)
|
|
ON CONFLICT (id) DO UPDATE SET
|
|
username = EXCLUDED.username,
|
|
email = EXCLUDED.email,
|
|
password_hash = EXCLUDED.password_hash
|
|
RETURNING id, username, email, password_hash, created_at",
|
|
)
|
|
.bind(*user.id.as_uuid())
|
|
.bind(&user.username)
|
|
.bind(user.email.as_str())
|
|
.bind(user.password_hash.as_str())
|
|
.bind(user.created_at)
|
|
.fetch_one(&self.pool)
|
|
.await
|
|
.map_err(|e| DomainError::Internal(e.to_string()))?;
|
|
Ok(())
|
|
}
|
|
|
|
async fn delete(&self, id: &SystemId) -> Result<(), DomainError> {
|
|
sqlx::query("DELETE FROM users WHERE id = $1")
|
|
.bind(*id.as_uuid())
|
|
.execute(&self.pool)
|
|
.await
|
|
.map_err(|e| DomainError::Internal(e.to_string()))?;
|
|
Ok(())
|
|
}
|
|
}
|