mabel/src/database/site.rs

use async_trait::async_trait;
use sqlx::Postgres;
use uuid::Uuid;

use crate::content::{
    site::{CollectionNameAndSlug, CreateSiteData, SiteData, SiteRepository, UpdateSiteData},
    Error,
};

use super::Database;

impl sqlx::Type<Postgres> for CollectionNameAndSlug {
    fn type_info() -> sqlx::postgres::PgTypeInfo {
        sqlx::postgres::PgTypeInfo::with_name("collection_name_slug")
    }
}

impl<'r> sqlx::Decode<'r, Postgres> for CollectionNameAndSlug {
    fn decode(
        value: sqlx::postgres::PgValueRef<'r>,
    ) -> Result<Self, Box<dyn std::error::Error + 'static + Send + Sync>> {
        let mut decoder = sqlx::postgres::types::PgRecordDecoder::new(value)?;
        let slug = decoder.try_decode::<String>()?;
        let name = decoder.try_decode::<String>()?;
        Ok(Self { name, slug })
    }
}

#[async_trait]
impl SiteRepository for Database {
    async fn get_site_by_name(&self, name: &str) -> Result<SiteData, Error> {
        let site = sqlx::query!(
            r#"SELECT
                sites.name,
                users.name as owner,
                COALESCE(users.display_name,users.name) as owner_display_name,
                title,
                description,
                sites.created_at,
                array_agg(row(collections.slug, collections.name)) as "collections!: Vec<CollectionNameAndSlug>"
            FROM sites
            JOIN
                users ON sites.owner = users.id
            JOIN
                collections ON collections.site = sites.id
            WHERE
                sites.name = $1
                AND sites.deleted_at IS NULL
            GROUP BY
                sites.name, users.name, users.display_name, title, description, sites.created_at"#,
            name
        )
        .fetch_one(&self.pool)
        .await
        .map_err(|e| match e {
            sqlx::Error::RowNotFound => Error::NotFound,
            _ => e.into(),
        })?;
        Ok(SiteData {
            name: site.name,
            owner: site.owner,
            owner_display_name: site.owner_display_name,
            title: site.title,
            description: site.description,
            created_at: site.created_at,
            collections: site.collections,
        })
    }

    async fn create_site(&self, owner: &Uuid, options: CreateSiteData) -> Result<Uuid, Error> {
        let result = sqlx::query!(
            "INSERT INTO sites (name, owner, title, description) VALUES ($1, $2, $3, $4) RETURNING id",
            options.name,
            owner,
            options.title,
            options.description,
        )
        .fetch_one(&self.pool)
        .await
        .map_err(|err| match err {
            sqlx::Error::Database(dberr) if dberr.constraint() == Some("sites_name_key") => {
                Error::IdentifierNotAvailable
            }
            _ => err.into(),
        })?;
        Ok(result.id)
    }

    async fn update_site(
        &self,
        owner: &Uuid,
        name: &str,
        options: UpdateSiteData,
    ) -> Result<(), Error> {
        let result = sqlx::query!(
            r#"UPDATE sites SET
                name = COALESCE($1, name),
                title = COALESCE($2, title),
                description = COALESCE($3, description),
                modified_at = NOW()
            WHERE
                name = $4
                AND owner = $5
                AND deleted_at IS NULL"#,
            options.name,
            options.title,
            options.description,
            name,
            owner,
        )
        .execute(&self.pool)
        .await
        .map_err(|err| match err {
            sqlx::Error::Database(dberr) if dberr.constraint() == Some("sites_name_key") => {
                Error::IdentifierNotAvailable
            }
            _ => err.into(),
        })?;

        if result.rows_affected() == 0 {
            return Err(Error::NotFound);
        }

        Ok(())
    }

    async fn delete_site(&self, owner: &Uuid, name: &str, soft_delete: bool) -> Result<(), Error> {
        let result = if soft_delete {
            sqlx::query!(
                // soft delete
                "UPDATE sites SET deleted_at = NOW() WHERE name = $1 AND owner = $2 AND deleted_at IS NULL",
                name, owner
             )
            .execute(&self.pool)
            .await?
        } else {
            sqlx::query!(
                // hard delete
                "DELETE FROM sites WHERE name = $1 AND owner = $2",
                name,
                owner,
            )
            .execute(&self.pool)
            .await?
        };

        if result.rows_affected() == 0 {
            return Err(Error::NotFound);
        }

        Ok(())
    }

    async fn get_site_id(&self, name: &str, owner: &Uuid) -> Result<Uuid, Error> {
        let record = sqlx::query!(
            "SELECT id FROM sites WHERE name = $1 AND owner = $2 AND deleted_at IS NULL",
            name,
            owner
        )
        .fetch_one(&self.pool)
        .await
        .map_err(|e| match e {
            sqlx::Error::RowNotFound => Error::NotFound,
            _ => e.into(),
        })?;
        Ok(record.id)
    }
}