actix-statusphere / src / models / auth_session.rs

use atrium_api::types::string::Did;
use serde::{Deserialize, Serialize};
use sqlx::PgPool;

/// [AuthSession] data type
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct AuthSession {
    pub key: String,
    pub session: String,
}

impl AuthSession {
    /// Creates a new [AuthSession]
    pub fn new<V>(key: String, session: V) -> Self
    where
        V: Serialize,
    {
        let session = serde_json::to_string(&session).unwrap();
        Self {
            key: key.to_string(),
            session,
        }
    }

    /// Gets an [AuthSession] by the users did(key)
    pub async fn get_by_did(pool: &PgPool, did: String) -> Result<Option<Self>, sqlx::Error> {
        let did = Did::new(did).unwrap();

        sqlx::query_as!(
            AuthSession,
            r#"
                SELECT *
                FROM auth_sessions
                WHERE key = $1
            "#,
            did.as_str()
        )
        .fetch_optional(pool)
        .await
    }

    /// Saves or updates the [AuthSession] by its did(key)
    pub async fn save_or_update(&self, pool: &PgPool) -> Result<(), sqlx::Error> {
        let mut transaction = pool.begin().await?;
        let exists: Option<bool> = sqlx::query_scalar!(
            r#"
                SELECT EXISTS(
                    SELECT *
                    FROM auth_sessions
                    WHERE key = $1
                )
            "#,
            self.key.clone()
        )
        .fetch_one(transaction.as_mut())
        .await?;

        if let Some(exists) = exists {
            match exists {
                true => {
                    sqlx::query!(
                        r#"
                            UPDATE auth_sessions
                            SET session = $2
                            WHERE key = $1
                        "#,
                        self.key,
                        self.session
                    )
                    .execute(transaction.as_mut())
                    .await?;
                }
                false => {
                    sqlx::query!(
                        r#"
                            INSERT INTO auth_sessions (key, session) VALUES ($1, $2)
                        "#,
                        self.key,
                        self.session
                    )
                    .execute(transaction.as_mut())
                    .await?;
                }
            }
        }

        transaction.commit().await?;

        Ok(())
    }

    /// Deletes the [AuthSession] by did
    pub async fn delete_by_did(pool: &PgPool, did: String) -> Result<(), sqlx::Error> {
        sqlx::query!(
            r#"
                DELETE FROM auth_sessions WHERE key = $1
            "#,
            did.as_str()
        )
        .execute(pool)
        .await?;

        Ok(())
    }

    /// Deletes all [AuthSession] rows
    pub async fn delete_all(pool: &PgPool) -> Result<(), sqlx::Error> {
        sqlx::query!(
            r#"
                DELETE FROM auth_sessions
            "#
        )
        .execute(pool)
        .await?;

        Ok(())
    }
}