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.

feat(ownership): documents register documents in the entity table (#6454)

Will Hutchinson7a6d3e073e8e
diff --git a/.github/workspace-dep-closures.json b/.github/workspace-dep-closures.json
index dd3c7b4942..b7e4b0fb72 100644
--- a/.github/workspace-dep-closures.json
+++ b/.github/workspace-dep-closures.json
@@ -1997,6 +1997,8 @@
"crates/entity_access_db_utils",
"crates/entity_access_management",
"crates/entity_mutation",
+ "crates/entity_registry/entity_registry_db_utils",
+ "crates/entity_registry/shared_entity_registry",
"crates/filter_ast",
"crates/foreign_entity",
"crates/frecency",
@@ -3224,6 +3226,8 @@
"crates/entity_access_db_utils",
"crates/entity_access_management",
"crates/entity_mutation",
+ "crates/entity_registry/entity_registry_db_utils",
+ "crates/entity_registry/shared_entity_registry",
"crates/filter_ast",
"crates/foreign_entity",
"crates/frecency",
@@ -3306,6 +3310,8 @@
"crates/entity_access_db_utils",
"crates/entity_access_management",
"crates/entity_mutation",
+ "crates/entity_registry/entity_registry_db_utils",
+ "crates/entity_registry/shared_entity_registry",
"crates/filter_ast",
"crates/foreign_entity",
"crates/frecency",
@@ -4277,6 +4283,8 @@
"crates/entity_access_db_utils",
"crates/entity_access_management",
"crates/entity_mutation",
+ "crates/entity_registry/entity_registry_db_utils",
+ "crates/entity_registry/shared_entity_registry",
"crates/filter_ast",
"crates/foreign_entity",
"crates/frecency",
@@ -8802,6 +8810,8 @@
"crates/entity_access_db_utils",
"crates/entity_access_management",
"crates/entity_mutation",
+ "crates/entity_registry/entity_registry_db_utils",
+ "crates/entity_registry/shared_entity_registry",
"crates/filter_ast",
"crates/foreign_entity",
"crates/frecency",
diff --git a/Cargo.lock b/Cargo.lock
index 88b6765416..58102aea0c 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -5579,6 +5579,7 @@ dependencies = [
"entity_access_db_utils",
"entity_access_management",
"entity_mutation",
+ "entity_registry_db_utils",
"foreign_entity",
"futures",
"hex",
@@ -5603,6 +5604,7 @@ dependencies = [
"model-entity",
"model-error-response",
"model_file_type",
+ "model_owner",
"model_user",
"models_permissions",
"models_properties",
diff --git a/crates/documents/Cargo.toml b/crates/documents/Cargo.toml
index ce3c9b6d57..da03d53c25 100644
--- a/crates/documents/Cargo.toml
+++ b/crates/documents/Cargo.toml
@@ -67,6 +67,8 @@ outbound = [
"dep:aws-sdk-s3",
"dep:base64",
"dep:entity_access_db_utils",
+ "dep:entity_registry_db_utils",
+ "dep:model_owner",
"dep:hex",
"dep:share_permission_db_utils",
"dep:sqlx",
@@ -142,6 +144,8 @@ base64 = { workspace = true, optional = true }
cloudfront_sign = { workspace = true }
comms_db_client = { path = "../comms_db_client", optional = true }
entity_access_db_utils = { path = "../entity_access_db_utils", optional = true }
+entity_registry_db_utils = { path = "../entity_registry/entity_registry_db_utils", optional = true }
+model_owner = { path = "../model_owner", optional = true }
futures = { workspace = true }
share_permission_db_utils = { path = "../share_permission_db_utils", optional = true }
hex = { workspace = true, optional = true }
diff --git a/crates/documents/src/outbound/pg_document_repo.rs b/crates/documents/src/outbound/pg_document_repo.rs
index 4a03ae2037..89c9fbe5a9 100644
--- a/crates/documents/src/outbound/pg_document_repo.rs
+++ b/crates/documents/src/outbound/pg_document_repo.rs
@@ -109,6 +109,12 @@ async fn update_document_modified(pool: &PgPool, document_id: &str) -> Result<()
Ok(())
}
+fn registry_protocol_error(
+ error: rootcause::Report<entity_registry_db_utils::EntityRegistryError>,
+) -> sqlx::Error {
+ sqlx::Error::Protocol(error.to_string())
+}
+
impl DocumentRepo for PgDocumentRepo {
type Err = sqlx::Error;
@@ -295,7 +301,6 @@ impl DocumentRepo for PgDocumentRepo {
async fn soft_delete_document(&self, document_id: &str) -> Result<(), Self::Err> {
let mut transaction = self.pool.begin().await?;
- // Delete pins
sqlx::query!(
r#"
DELETE FROM "Pin" WHERE "pinnedItemId" = $1 AND "pinnedItemType" = $2
@@ -306,7 +311,6 @@ impl DocumentRepo for PgDocumentRepo {
.execute(&mut *transaction)
.await?;
- // Delete from history
sqlx::query!(
r#"
DELETE FROM "UserHistory" WHERE "itemId" = $1 AND "itemType" = $2
@@ -317,7 +321,6 @@ impl DocumentRepo for PgDocumentRepo {
.execute(&mut *transaction)
.await?;
- // Soft delete the document
sqlx::query!(
r#"
UPDATE "Document"
@@ -329,6 +332,12 @@ impl DocumentRepo for PgDocumentRepo {
.execute(&mut *transaction)
.await?;
+ if let Ok(id) = macro_uuid::string_to_uuid(document_id) {
+ entity_registry_db_utils::mark_deleted(&mut transaction, id, chrono::Utc::now())
+ .await
+ .map_err(registry_protocol_error)?;
+ }
+
transaction.commit().await?;
Ok(())
}
@@ -654,10 +663,16 @@ impl DocumentRepo for PgDocumentRepo {
#[tracing::instrument(err, skip(self))]
async fn delete_document_by_id(&self, document_id: &str) -> Result<(), Self::Err> {
- sqlx::query!(r#"DELETE FROM "Document" WHERE id = $1"#, document_id,)
- .execute(&self.pool)
+ let mut transaction = self.pool.begin().await?;
+ sqlx::query!(r#"DELETE FROM "Document" WHERE id = $1"#, document_id)
+ .execute(&mut *transaction)
.await?;
-
+ if let Ok(id) = macro_uuid::string_to_uuid(document_id) {
+ entity_registry_db_utils::delete_entity(&mut transaction, id)
+ .await
+ .map_err(registry_protocol_error)?;
+ }
+ transaction.commit().await?;
Ok(())
}
@@ -1107,10 +1122,8 @@ impl DocumentRepo for PgDocumentRepo {
create::allocate_team_task_number(&mut transaction, team_id, &document_id).await?;
}
- // Create share permission
create::set_share_permission(&mut transaction, &document_id, &share_permission).await?;
- // Insert user entity access (Owner level)
entity_access_db_utils::insert_entity_access_row(
&mut transaction,
&document_id,
@@ -1121,7 +1134,17 @@ impl DocumentRepo for PgDocumentRepo {
)
.await?;
- // Insert user history
+ 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(user_id.clone()),
+ ),
+ )
+ .await
+ .map_err(registry_protocol_error)?;
+
let now = chrono::Utc::now();
create::insert_history(&mut transaction, &document_id, &user_id, &now).await?;
diff --git a/crates/documents/src/outbound/pg_document_repo/create.rs b/crates/documents/src/outbound/pg_document_repo/create.rs
index 67f7f7d29d..777b84a194 100644
--- a/crates/documents/src/outbound/pg_document_repo/create.rs
+++ b/crates/documents/src/outbound/pg_document_repo/create.rs
@@ -454,6 +454,17 @@ pub async fn insert_new_document(
)
.await?;
+ entity_registry_db_utils::insert_entity(
+ transaction,
+ entity_registry_db_utils::NewEntityRecord::new(
+ document_id,
+ entity_registry_db_utils::RegisteredEntityType::Document,
+ model_owner::Owner::User(user_id.clone()),
+ ),
+ )
+ .await
+ .map_err(|error| DocumentError::Internal(error.into()))?;
+
if share_with_team {
let document_id_string = document_id.to_string();
let entity = model_entity::EntityType::Document.with_entity_str(&document_id_string);
diff --git a/crates/documents/src/outbound/pg_document_repo/tests.rs b/crates/documents/src/outbound/pg_document_repo/tests.rs
index 0d5783fb2e..7812e3bff3 100644
--- a/crates/documents/src/outbound/pg_document_repo/tests.rs
+++ b/crates/documents/src/outbound/pg_document_repo/tests.rs
@@ -397,6 +397,7 @@ async fn task_creation_failure_rolls_back_all_initialization(pool: Pool<Postgres
.unwrap(),
Some(0)
);
+ assert_eq!(count_entity_rows_for_id(&pool, &id.to_string()).await, 0);
assert!(team_task_numbers(&pool, TEST_TEAM_ID).await.is_empty());
sqlx::raw_sql(
@@ -456,6 +457,7 @@ async fn task_creation_failure_rolls_back_all_initialization(pool: Pool<Postgres
.unwrap(),
Some(0)
);
+ assert_eq!(count_entity_rows_for_id(&pool, &id.to_string()).await, 0);
assert!(team_task_numbers(&pool, TEST_TEAM_ID).await.is_empty());
}
@@ -492,6 +494,45 @@ fn create_document_args(
}
}
+struct EntityRow {
+ owner_type: String,
+ owner_id: String,
+ entity_type: String,
+ deleted_at: Option<chrono::DateTime<chrono::Utc>>,
+}
+
+async fn fetch_entity_row(pool: &Pool<Postgres>, document_id: &str) -> EntityRow {
+ let row = sqlx::query(
+ r#"
+ SELECT
+ owner_type::text AS owner_type,
+ owner_id,
+ entity_type,
+ deleted_at
+ FROM entity
+ WHERE id = $1
+ "#,
+ )
+ .bind(uuid::Uuid::parse_str(document_id).unwrap())
+ .fetch_one(pool)
+ .await
+ .unwrap();
+ EntityRow {
+ owner_type: row.get("owner_type"),
+ owner_id: row.get("owner_id"),
+ entity_type: row.get("entity_type"),
+ deleted_at: row.get("deleted_at"),
+ }
+}
+
+async fn count_entity_rows_for_id(pool: &Pool<Postgres>, document_id: &str) -> i64 {
+ sqlx::query_scalar("SELECT COUNT(*) FROM entity WHERE id::text = $1")
+ .bind(document_id)
+ .fetch_one(pool)
+ .await
+ .unwrap()
+}
+
/// The no-team default permission for an md document — the repo persists whatever
/// the domain layer resolved, so tests pass it explicitly.
fn md_share_permission() -> SharePermissionV2 {
@@ -2694,3 +2735,261 @@ async fn test_import_email_attachment_only_reuses_latest_instance_sha(pool: Pool
assert!(matches!(superseded, EmailImportRepoOutcome::Created(_)));
assert_ne!(document_id, superseded.metadata().document_id);
}
+
+#[sqlx::test(
+ migrator = "MACRO_DB_MIGRATIONS",
+ fixtures(path = "../../../fixtures", scripts("documents_test_data"))
+)]
+async fn create_document_registers_entity_row(pool: Pool<Postgres>) {
+ let repo = PgDocumentRepo::new(pool.clone());
+ let document = repo
+ .create_document(
+ create_document_args(TEST_DOCUMENT_OWNER_ID, false, None),
+ md_share_permission(),
+ )
+ .await
+ .unwrap();
+
+ let entity = fetch_entity_row(&pool, &document.document_id).await;
+ assert_eq!(entity.entity_type, "document");
+ assert_eq!(entity.owner_type, "user");
+ assert_eq!(entity.owner_id, TEST_DOCUMENT_OWNER_ID);
+ assert_eq!(entity.deleted_at, None);
+ assert_eq!(
+ count_entity_rows_for_id(&pool, &document.document_id).await,
+ 1
+ );
+}
+
+#[sqlx::test(
+ migrator = "MACRO_DB_MIGRATIONS",
+ fixtures(path = "../../../fixtures", scripts("documents_test_data"))
+)]
+async fn copy_document_registers_distinct_entity_row(pool: Pool<Postgres>) {
+ let repo = PgDocumentRepo::new(pool.clone());
+ let original = create_task_for_team(&repo, TEST_DOCUMENT_OWNER_ID, TEST_TEAM_ID).await;
+
+ let copied = repo
+ .copy_document(
+ CopyDocumentRepoArgs {
+ original_document: original.clone(),
+ user_id: user_id(TEST_DOCUMENT_OWNER_ID),
+ document_name: "copied task".to_string(),
+ file_type: Some(model::document::FileType::Md),
+ team_id: Some(TEST_TEAM_ID),
+ },
+ md_share_permission(),
+ )
+ .await
+ .unwrap();
+
+ assert_ne!(original.document_id, copied.document_id);
+
+ let source = fetch_entity_row(&pool, &original.document_id).await;
+ let copy = fetch_entity_row(&pool, &copied.document_id).await;
+ assert_eq!(source.entity_type, "document");
+ assert_eq!(copy.entity_type, "document");
+ assert_eq!(source.owner_type, "user");
+ assert_eq!(copy.owner_type, "user");
+ assert_eq!(source.owner_id, TEST_DOCUMENT_OWNER_ID);
+ assert_eq!(copy.owner_id, TEST_DOCUMENT_OWNER_ID);
+ assert_eq!(source.deleted_at, None);
+ assert_eq!(copy.deleted_at, None);
+ assert_eq!(
+ count_entity_rows_for_id(&pool, &original.document_id).await,
+ 1
+ );
+ assert_eq!(
+ count_entity_rows_for_id(&pool, &copied.document_id).await,
+ 1
+ );
+}
+
+#[sqlx::test(
+ migrator = "MACRO_DB_MIGRATIONS",
+ fixtures(path = "../../../fixtures", scripts("documents_test_data"))
+)]
+async fn import_email_created_registers_one_entity_row(pool: Pool<Postgres>) {
+ let repo = PgDocumentRepo::new(pool.clone());
+ let attachments = insert_email_attachments(&pool, 1).await;
+ let sha = "eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee";
+
+ let created = repo
+ .import_email_attachment_document(
+ import_email_document_args(TEST_DOCUMENT_OWNER_ID, sha, attachments[0]),
+ pdf_share_permission(),
+ )
+ .await
+ .unwrap();
+
+ assert!(matches!(created, EmailImportRepoOutcome::Created(_)));
+ let document_id = &created.metadata().document_id;
+ let entity = fetch_entity_row(&pool, document_id).await;
+ assert_eq!(entity.entity_type, "document");
+ assert_eq!(entity.owner_type, "user");
+ assert_eq!(entity.owner_id, TEST_DOCUMENT_OWNER_ID);
+ assert_eq!(entity.deleted_at, None);
+ assert_eq!(count_entity_rows_for_id(&pool, document_id).await, 1);
+}
+
+#[sqlx::test(
+ migrator = "MACRO_DB_MIGRATIONS",
+ fixtures(path = "../../../fixtures", scripts("documents_test_data"))
+)]
+async fn import_email_reuse_keeps_one_entity_row_on_original(pool: Pool<Postgres>) {
+ let repo = PgDocumentRepo::new(pool.clone());
+ let attachments = insert_email_attachments(&pool, 2).await;
+ let sha = "ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff";
+
+ let first = repo
+ .import_email_attachment_document(
+ import_email_document_args(TEST_DOCUMENT_OWNER_ID, sha, attachments[0]),
+ pdf_share_permission(),
+ )
+ .await
+ .unwrap();
+ let sha_reuse = repo
+ .import_email_attachment_document(
+ import_email_document_args(TEST_DOCUMENT_OWNER_ID, sha, attachments[1]),
+ pdf_share_permission(),
+ )
+ .await
+ .unwrap();
+ let same_attachment = repo
+ .import_email_attachment_document(
+ import_email_document_args(TEST_DOCUMENT_OWNER_ID, sha, attachments[0]),
+ pdf_share_permission(),
+ )
+ .await
+ .unwrap();
+
+ assert!(matches!(first, EmailImportRepoOutcome::Created(_)));
+ assert!(matches!(sha_reuse, EmailImportRepoOutcome::Reused(_)));
+ assert!(matches!(same_attachment, EmailImportRepoOutcome::Reused(_)));
+ let original_id = first.metadata().document_id.clone();
+ assert_eq!(original_id, sha_reuse.metadata().document_id);
+ assert_eq!(original_id, same_attachment.metadata().document_id);
+ assert_eq!(count_entity_rows_for_id(&pool, &original_id).await, 1);
+}
+
+#[sqlx::test(
+ migrator = "MACRO_DB_MIGRATIONS",
+ fixtures(path = "../../../fixtures", scripts("documents_test_data"))
+)]
+async fn soft_delete_document_sets_entity_deleted_at(pool: Pool<Postgres>) {
+ let repo = PgDocumentRepo::new(pool.clone());
+ let document = repo
+ .create_document(
+ create_document_args(TEST_DOCUMENT_OWNER_ID, false, None),
+ md_share_permission(),
+ )
+ .await
+ .unwrap();
+
+ repo.soft_delete_document(&document.document_id)
+ .await
+ .unwrap();
+
+ let entity = fetch_entity_row(&pool, &document.document_id).await;
+ assert!(entity.deleted_at.is_some());
+}
+
+#[sqlx::test(
+ migrator = "MACRO_DB_MIGRATIONS",
+ fixtures(path = "../../../fixtures", scripts("documents_test_data"))
+)]
+async fn delete_document_by_id_removes_entity_row(pool: Pool<Postgres>) {
+ let repo = PgDocumentRepo::new(pool.clone());
+ let document = repo
+ .create_document(
+ create_document_args(TEST_DOCUMENT_OWNER_ID, false, None),
+ md_share_permission(),
+ )
+ .await
+ .unwrap();
+
+ repo.delete_document_by_id(&document.document_id)
+ .await
+ .unwrap();
+
+ assert_eq!(
+ count_entity_rows_for_id(&pool, &document.document_id).await,
+ 0
+ );
+}
+
+#[sqlx::test(
+ migrator = "MACRO_DB_MIGRATIONS",
+ fixtures(path = "../../../fixtures", scripts("documents_test_data"))
+)]
+async fn soft_delete_and_hard_delete_tolerate_missing_entity_row(pool: Pool<Postgres>) {
+ let repo = PgDocumentRepo::new(pool.clone());
+
+ repo.soft_delete_document(TEST_DOCUMENT_ID).await.unwrap();
+ assert_eq!(count_entity_rows_for_id(&pool, TEST_DOCUMENT_ID).await, 0);
+
+ let document = repo
+ .create_document(
+ create_document_args(TEST_DOCUMENT_OWNER_ID, false, None),
+ md_share_permission(),
+ )
+ .await
+ .unwrap();
+ sqlx::query("DELETE FROM entity WHERE id::text = $1")
+ .bind(&document.document_id)
+ .execute(&pool)
+ .await
+ .unwrap();
+
+ repo.soft_delete_document(&document.document_id)
+ .await
+ .unwrap();
+ repo.delete_document_by_id(&document.document_id)
+ .await
+ .unwrap();
+ assert_eq!(
+ count_entity_rows_for_id(&pool, &document.document_id).await,
+ 0
+ );
+}
+
+#[sqlx::test(
+ migrator = "MACRO_DB_MIGRATIONS",
+ fixtures(path = "../../../fixtures", scripts("documents_test_data"))
+)]
+async fn task_snippet_and_skill_register_one_document_entity_row(pool: Pool<Postgres>) {
+ let repo = PgDocumentRepo::new(pool.clone());
+ let task = create_task_for_team(&repo, TEST_DOCUMENT_OWNER_ID, TEST_TEAM_ID).await;
+ assert_eq!(count_entity_rows_for_id(&pool, &task.document_id).await, 1);
+ assert_eq!(
+ fetch_entity_row(&pool, &task.document_id).await.entity_type,
+ "document"
+ );
+ assert_eq!(
+ task.sub_type,
+ Some(document_sub_type::DocumentSubType::Task)
+ );
+
+ for sub_type in [
+ document_sub_type::DocumentSubType::Snippet,
+ document_sub_type::DocumentSubType::Skill,
+ ] {
+ let mut args = create_document_args(TEST_DOCUMENT_OWNER_ID, false, None);
+ args.sub_type = Some(sub_type);
+ let document = repo
+ .create_document(args, md_share_permission())
+ .await
+ .unwrap();
+ assert_eq!(document.sub_type, Some(sub_type));
+ assert_eq!(
+ count_entity_rows_for_id(&pool, &document.document_id).await,
+ 1
+ );
+ assert_eq!(
+ fetch_entity_row(&pool, &document.document_id)
+ .await
+ .entity_type,
+ "document"
+ );
+ }
+}
diff --git a/crates/macro_db_client/src/document/delete_document.rs b/crates/macro_db_client/src/document/delete_document.rs
index ca612d6070..628331e142 100644
--- a/crates/macro_db_client/src/document/delete_document.rs
+++ b/crates/macro_db_client/src/document/delete_document.rs
@@ -6,7 +6,6 @@ use sqlx::{Pool, Postgres, Transaction};
#[tracing::instrument(skip(db))]
pub async fn delete_document(db: &Pool<Postgres>, document_id: &str) -> anyhow::Result<()> {
let mut transaction = db.begin().await?;
- // Delete pins
sqlx::query!(
r#"
DELETE FROM "Pin" WHERE "pinnedItemId" = $1 AND "pinnedItemType" = $2
@@ -17,7 +16,6 @@ pub async fn delete_document(db: &Pool<Postgres>, document_id: &str) -> anyhow::
.execute(&mut *transaction)
.await?;
- // Delete from history
sqlx::query!(
r#"
DELETE FROM "UserHistory" WHERE "itemId" = $1 AND "itemType" = $2
@@ -28,7 +26,6 @@ pub async fn delete_document(db: &Pool<Postgres>, document_id: &str) -> anyhow::
.execute(&mut *transaction)
.await?;
- // Get share permission if present
let share_permission: Option<String> = sqlx::query!(
r#"
SELECT "sharePermissionId" as share_permission_id
@@ -41,7 +38,6 @@ pub async fn delete_document(db: &Pool<Postgres>, document_id: &str) -> anyhow::
.await?;
if let Some(share_permission) = share_permission {
- // Delete share permission
sqlx::query!(
r#"
DELETE FROM "SharePermission" WHERE id = $1"#,
@@ -51,7 +47,6 @@ pub async fn delete_document(db: &Pool<Postgres>, document_id: &str) -> anyhow::
.await?;
}
- // Delete document
sqlx::query!(r#"DELETE FROM "Document" WHERE id = $1"#, document_id)
.execute(&mut *transaction)
.await?;
@@ -63,6 +58,10 @@ pub async fn delete_document(db: &Pool<Postgres>, document_id: &str) -> anyhow::
)
.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));
@@ -211,6 +210,7 @@ pub async fn get_shas_for_deletion(
#[cfg(test)]
mod tests {
use super::*;
+ use macro_user_id::cowlike::CowLike;
use sqlx::{Pool, Postgres};
#[sqlx::test(fixtures(path = "../../fixtures", scripts("docx_example")))]
@@ -225,4 +225,75 @@ mod tests {
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);
+ }
}
diff --git a/crates/macro_db_client/src/document/revert_delete.rs b/crates/macro_db_client/src/document/revert_delete.rs
index 193faf1afc..5ed785b75d 100644
--- a/crates/macro_db_client/src/document/revert_delete.rs
+++ b/crates/macro_db_client/src/document/revert_delete.rs
@@ -10,7 +10,6 @@ pub async fn revert_delete_document(
) -> anyhow::Result<()> {
let mut transaction = db.begin().await.context("unable to begin transaction")?;
- // Remove deletedAt for document
let document_owner = sqlx::query!(
r#"
UPDATE "Document"
@@ -25,7 +24,10 @@ pub async fn revert_delete_document(
.await
.context("unable to update document")?;
- // Add document back to history
+ if let Ok(document_uuid) = macro_uuid::string_to_uuid(document_id) {
+ entity_registry_db_utils::clear_deleted(&mut transaction, document_uuid).await?;
+ }
+
sqlx::query!(
r#"
INSERT INTO "UserHistory" ("userId", "itemId", "itemType", "createdAt", "updatedAt")
@@ -78,6 +80,7 @@ pub async fn revert_delete_document(
#[cfg(test)]
mod tests {
use super::*;
+ use macro_user_id::cowlike::CowLike;
use sqlx::{Pool, Postgres};
#[sqlx::test(fixtures(path = "../../fixtures", scripts("basic_user_with_document")))]
@@ -186,4 +189,87 @@ mod tests {
Ok(())
}
+
+ #[sqlx::test(fixtures(path = "../../fixtures", scripts("basic_user_with_document")))]
+ async fn revert_delete_document_clears_entity_deleted_at(
+ pool: Pool<Postgres>,
+ ) -> anyhow::Result<()> {
+ let document_id = uuid::Uuid::new_v4();
+ sqlx::query(
+ r#"
+ INSERT INTO "Document" (id, name, "fileType", owner, "deletedAt")
+ VALUES ($1, 'uuid-doc', 'md', 'macro|[email protected]', NOW())
+ "#,
+ )
+ .bind(document_id.to_string())
+ .execute(&pool)
+ .await?;
+
+ let mut transaction = pool.begin().await?;
+ 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]")?
+ .into_owned(),
+ ),
+ ),
+ )
+ .await?;
+ entity_registry_db_utils::mark_deleted(&mut transaction, document_id, chrono::Utc::now())
+ .await?;
+ transaction.commit().await?;
+
+ revert_delete_document(&pool, &document_id.to_string(), None).await?;
+
+ let deleted_at: Option<chrono::DateTime<chrono::Utc>> = sqlx::query_scalar(
+ r#"
+ SELECT deleted_at FROM entity WHERE id = $1
+ "#,
+ )
+ .bind(document_id)
+ .fetch_one(&pool)
+ .await?;
+ assert_eq!(deleted_at, None);
+
+ Ok(())
+ }
+
+ #[sqlx::test(fixtures(path = "../../fixtures", scripts("basic_user_with_document")))]
+ async fn revert_delete_document_succeeds_without_entity_row(
+ pool: Pool<Postgres>,
+ ) -> anyhow::Result<()> {
+ let document_id = uuid::Uuid::new_v4();
+ sqlx::query(
+ r#"
+ INSERT INTO "Document" (id, name, "fileType", owner, "deletedAt")
+ VALUES ($1, 'uuid-doc', 'md', 'macro|[email protected]', NOW())
+ "#,
+ )
+ .bind(document_id.to_string())
+ .execute(&pool)
+ .await?;
+
+ revert_delete_document(&pool, &document_id.to_string(), None).await?;
+
+ let document_deleted_at: Option<chrono::DateTime<chrono::Utc>> = sqlx::query_scalar(
+ r#"
+ SELECT "deletedAt" FROM "Document" WHERE id = $1
+ "#,
+ )
+ .bind(document_id.to_string())
+ .fetch_one(&pool)
+ .await?;
+ assert_eq!(document_deleted_at, None);
+
+ let entity_count: i64 = sqlx::query_scalar("SELECT COUNT(*) FROM entity WHERE id = $1")
+ .bind(document_id)
+ .fetch_one(&pool)
+ .await?;
+ assert_eq!(entity_count, 0);
+
+ Ok(())
+ }
}