Skip to content

armgit / macro

Public Imported from GitHub
0

Macro is a unified workspace for teams: email, chat, docs, tasks, agents, calls, and CRM — @-linked together with shared AI memory.

8.7 KB
Raw Blame
use model_entity::EntityType;
use sqlx::{Pool, Postgres, Transaction};

/// Hard deletes a document from the database.
/// Removing the history and pins for the document as well.
#[tracing::instrument(skip(db))]
pub async fn delete_document(db: &Pool<Postgres>, document_id: &str) -> anyhow::Result<()> {
    let mut transaction = db.begin().await?;
    sqlx::query!(
        r#"
        DELETE FROM "Pin" WHERE "pinnedItemId" = $1 AND "pinnedItemType" = $2
        "#,
        document_id,
        "document",
    )
    .execute(&mut *transaction)
    .await?;

    sqlx::query!(
        r#"
        DELETE FROM "UserHistory" WHERE "itemId" = $1 AND "itemType" = $2
        "#,
        document_id,
        "document",
    )
    .execute(&mut *transaction)
    .await?;

    let share_permission: Option<String> = sqlx::query!(
        r#"
            SELECT "sharePermissionId" as share_permission_id
            FROM "DocumentPermission"
            WHERE "documentId"=$1"#,
        document_id
    )
    .map(|row| row.share_permission_id)
    .fetch_optional(&mut *transaction)
    .await?;

    if let Some(share_permission) = share_permission {
        sqlx::query!(
            r#"
            DELETE FROM "SharePermission" WHERE id = $1"#,
            share_permission
        )
        .execute(&mut *transaction)
        .await?;
    }

    sqlx::query!(r#"DELETE FROM "Document" WHERE id = $1"#, document_id)
        .execute(&mut *transaction)
        .await?;

    crate::item_access::delete::delete_user_entity_access_by_item(
        &mut transaction,
        &macro_uuid::string_to_uuid(document_id).unwrap(),
        EntityType::Document,
    )
    .await?;

    if let Ok(document_uuid) = macro_uuid::string_to_uuid(document_id) {
        entity_registry_db_utils::delete_entity(&mut transaction, document_uuid).await?;
    }

    if let Err(e) = transaction.commit().await {
        tracing::error!(error=?e, "unable to commit transaction");
        return Err(anyhow::Error::from(e));
    }
    Ok(())
}

/// Hard deletes documents in bulk from the database.
#[tracing::instrument(skip(transaction))]
pub async fn delete_document_bulk_tsx(
    transaction: &mut Transaction<'_, Postgres>,
    document_ids: &[impl ToString + std::fmt::Debug],
) -> anyhow::Result<()> {
    let document_ids: Vec<String> = document_ids.iter().map(|s| s.to_string()).collect();
    // Delete pins
    sqlx::query!(
        r#"
        DELETE FROM "Pin" WHERE "pinnedItemId" = ANY($1) AND "pinnedItemType" = $2
        "#,
        &document_ids,
        "document",
    )
    .execute(transaction.as_mut())
    .await?;

    // Delete from history
    sqlx::query!(
        r#"
        DELETE FROM "UserHistory" WHERE "itemId" = ANY($1) AND "itemType" = $2
        "#,
        &document_ids,
        "document",
    )
    .execute(transaction.as_mut())
    .await?;

    // Delete SharePermissions
    sqlx::query!(
        r#"
        DELETE FROM "SharePermission" sp
        USING "DocumentPermission" dp 
        WHERE dp."sharePermissionId" = sp.id
        AND dp."documentId" = ANY($1)
    "#,
        &document_ids,
    )
    .execute(transaction.as_mut())
    .await?;

    // Delete chats
    sqlx::query!(
        r#"
        DELETE FROM "Document" 
        WHERE id = ANY($1)
        "#,
        &document_ids,
    )
    .execute(transaction.as_mut())
    .await?;

    let document_uuids: Vec<uuid::Uuid> = document_ids
        .iter()
        .filter_map(|document_id| macro_uuid::string_to_uuid(document_id).ok())
        .collect();

    crate::item_access::delete::delete_user_entity_access_bulk(
        transaction,
        &document_uuids,
        EntityType::Document,
    )
    .await?;
    for document_uuid in document_uuids {
        entity_registry_db_utils::delete_entity(transaction, document_uuid).await?;
    }

    Ok(())
}

/// Deletes a document version from the database.
#[tracing::instrument(skip(db))]
pub async fn delete_document_version(
    db: &Pool<Postgres>,
    document_id: &str,
    document_version_id: i64,
    file_type: &str,
) -> anyhow::Result<()> {
    let total_count = sqlx::query!(
        r#"
        SELECT
            (SELECT COUNT(*) FROM "DocumentInstance" WHERE "documentId" = $1) +
            (SELECT COUNT(*) FROM "DocumentBom" WHERE "documentId" = $1) AS total_count
        "#,
        document_id
    )
    .fetch_one(db)
    .await?;

    if let Some(total_count) = total_count.total_count {
        // We need to delete the entire document
        if total_count == 1 {
            tracing::debug!("document total count is 1, deleting entire document");
            return delete_document(db, document_id).await;
        }
    }

    match file_type {
        "docx" => {
            sqlx::query!(
                r#"DELETE FROM "DocumentBom" WHERE id = $2 and "documentId" = $1"#,
                document_id,
                document_version_id
            )
            .execute(db)
            .await?;
        }
        _ => {
            sqlx::query!(
                r#"DELETE FROM "DocumentInstance" WHERE id = $2 and "documentId" = $1"#,
                document_id,
                document_version_id
            )
            .execute(db)
            .await?;
        }
    }

    Ok(())
}

/// Gets all the shas of a given document bom that are to be deleted.
pub async fn get_shas_for_deletion(
    db: Pool<Postgres>,
    document_id: &str,
) -> anyhow::Result<Vec<String>> {
    let result = sqlx::query!(
        r#"
        SELECT bp.sha
        FROM "BomPart" bp
        JOIN "DocumentBom" db ON bp."documentBomId" = db.id
        WHERE db."documentId" = $1
        "#,
        document_id,
    )
    .fetch_all(&db)
    .await
    .map_err(|err| anyhow::Error::msg(format!("unable to fetch shas for deletion: {:?}", err)))?;

    Ok(result.into_iter().map(|s| s.sha).collect::<Vec<String>>())
}

#[cfg(test)]
mod tests {
    use super::*;
    use macro_user_id::cowlike::CowLike;
    use sqlx::{Pool, Postgres};

    #[sqlx::test(fixtures(path = "../../fixtures", scripts("docx_example")))]
    async fn test_get_shas_for_deletion(pool: Pool<Postgres>) {
        let mut shas = get_shas_for_deletion(pool.clone(), "document-one")
            .await
            .unwrap();
        shas.sort();

        assert_eq!(
            shas,
            vec!["sha-1", "sha-1", "sha-2", "sha-2", "sha-3", "sha-4"]
        );
    }

    async fn insert_uuid_document(pool: &Pool<Postgres>) -> uuid::Uuid {
        let document_id = uuid::Uuid::new_v4();
        sqlx::query(
            r#"
            INSERT INTO "Document" (id, name, "fileType", owner)
            VALUES ($1, 'uuid-doc', 'md', 'macro|[email protected]')
            "#,
        )
        .bind(document_id.to_string())
        .execute(pool)
        .await
        .unwrap();
        document_id
    }

    async fn insert_entity_row(pool: &Pool<Postgres>, document_id: uuid::Uuid) {
        let mut transaction = pool.begin().await.unwrap();
        entity_registry_db_utils::insert_entity(
            &mut transaction,
            entity_registry_db_utils::NewEntityRecord::new(
                document_id,
                entity_registry_db_utils::RegisteredEntityType::Document,
                model_owner::Owner::User(
                    macro_user_id::user_id::MacroUserIdStr::parse_from_str("macro|[email protected]")
                        .unwrap()
                        .into_owned(),
                ),
            ),
        )
        .await
        .unwrap();
        transaction.commit().await.unwrap();
    }

    async fn count_entity_rows(pool: &Pool<Postgres>, document_id: uuid::Uuid) -> i64 {
        sqlx::query_scalar("SELECT COUNT(*) FROM entity WHERE id = $1")
            .bind(document_id)
            .fetch_one(pool)
            .await
            .unwrap()
    }

    #[sqlx::test(fixtures(path = "../../fixtures", scripts("basic_user_with_document")))]
    async fn delete_document_removes_entity_row(pool: Pool<Postgres>) {
        let document_id = insert_uuid_document(&pool).await;
        insert_entity_row(&pool, document_id).await;

        delete_document(&pool, &document_id.to_string())
            .await
            .unwrap();

        assert_eq!(count_entity_rows(&pool, document_id).await, 0);
    }

    #[sqlx::test(fixtures(path = "../../fixtures", scripts("basic_user_with_document")))]
    async fn delete_document_succeeds_without_entity_row(pool: Pool<Postgres>) {
        let document_id = insert_uuid_document(&pool).await;

        delete_document(&pool, &document_id.to_string())
            .await
            .unwrap();

        assert_eq!(count_entity_rows(&pool, document_id).await, 0);
        let remaining: i64 = sqlx::query_scalar(r#"SELECT COUNT(*) FROM "Document" WHERE id = $1"#)
            .bind(document_id.to_string())
            .fetch_one(&pool)
            .await
            .unwrap();
        assert_eq!(remaining, 0);
    }
}