108 lines
3.2 KiB
Rust
108 lines
3.2 KiB
Rust
use async_trait::async_trait;
|
|
use sqlx::{FromRow, SqlitePool};
|
|
|
|
use domain::{
|
|
auth::{RefreshSession, RefreshSessionId, ports::RefreshSessionRepository},
|
|
errors::DomainResult,
|
|
user::UserId,
|
|
};
|
|
|
|
use crate::db::{RepoExt, parse_dt};
|
|
|
|
pub struct SqliteRefreshSessionRepository {
|
|
pool: SqlitePool,
|
|
}
|
|
|
|
impl SqliteRefreshSessionRepository {
|
|
pub fn new(pool: SqlitePool) -> Self {
|
|
Self { pool }
|
|
}
|
|
}
|
|
|
|
#[derive(FromRow)]
|
|
struct RefreshSessionRow {
|
|
id: String,
|
|
user_id: String,
|
|
token: String,
|
|
expires_at: String,
|
|
created_at: String,
|
|
}
|
|
|
|
impl TryFrom<RefreshSessionRow> for RefreshSession {
|
|
type Error = domain::errors::DomainError;
|
|
|
|
fn try_from(row: RefreshSessionRow) -> Result<Self, Self::Error> {
|
|
use domain::errors::DomainError;
|
|
let id = RefreshSessionId::from_uuid(
|
|
uuid::Uuid::parse_str(&row.id)
|
|
.map_err(|e| DomainError::Repository(format!("invalid session uuid: {e}")))?,
|
|
);
|
|
let user_id = UserId::from_uuid(
|
|
uuid::Uuid::parse_str(&row.user_id)
|
|
.map_err(|e| DomainError::Repository(format!("invalid user uuid: {e}")))?,
|
|
);
|
|
let expires_at = parse_dt(&row.expires_at)?;
|
|
let created_at = parse_dt(&row.created_at)?;
|
|
Ok(RefreshSession::from_persistence(
|
|
id, user_id, row.token, expires_at, created_at,
|
|
))
|
|
}
|
|
}
|
|
|
|
#[async_trait]
|
|
impl RefreshSessionRepository for SqliteRefreshSessionRepository {
|
|
async fn create(&self, session: &RefreshSession) -> DomainResult<()> {
|
|
sqlx::query(
|
|
"INSERT INTO refresh_sessions (id, user_id, token, expires_at, created_at) VALUES (?, ?, ?, ?, ?)",
|
|
)
|
|
.bind(session.id().as_uuid().to_string())
|
|
.bind(session.user_id().as_uuid().to_string())
|
|
.bind(session.token())
|
|
.bind(session.expires_at().to_rfc3339())
|
|
.bind(session.created_at().to_rfc3339())
|
|
.execute(&self.pool)
|
|
.await
|
|
.repo()
|
|
.map(|_| ())
|
|
}
|
|
|
|
async fn find_by_token(&self, token: &str) -> DomainResult<Option<RefreshSession>> {
|
|
sqlx::query_as::<_, RefreshSessionRow>(
|
|
"SELECT id, user_id, token, expires_at, created_at FROM refresh_sessions WHERE token = ?",
|
|
)
|
|
.bind(token)
|
|
.fetch_optional(&self.pool)
|
|
.await
|
|
.repo()?
|
|
.map(RefreshSession::try_from)
|
|
.transpose()
|
|
}
|
|
|
|
async fn revoke(&self, token: &str) -> DomainResult<()> {
|
|
sqlx::query("DELETE FROM refresh_sessions WHERE token = ?")
|
|
.bind(token)
|
|
.execute(&self.pool)
|
|
.await
|
|
.repo()
|
|
.map(|_| ())
|
|
}
|
|
|
|
async fn revoke_all_for_user(&self, user_id: &UserId) -> DomainResult<()> {
|
|
sqlx::query("DELETE FROM refresh_sessions WHERE user_id = ?")
|
|
.bind(user_id.as_uuid().to_string())
|
|
.execute(&self.pool)
|
|
.await
|
|
.repo()
|
|
.map(|_| ())
|
|
}
|
|
|
|
async fn delete_expired(&self) -> DomainResult<u64> {
|
|
let result = sqlx::query("DELETE FROM refresh_sessions WHERE expires_at < ?")
|
|
.bind(chrono::Utc::now().to_rfc3339())
|
|
.execute(&self.pool)
|
|
.await
|
|
.repo()?;
|
|
Ok(result.rows_affected())
|
|
}
|
|
}
|