Macro is a unified workspace for teams: email, chat, docs, tasks, agents, calls, and CRM — @-linked together with shared AI memory.
TypeScript agentaiai-agentsall-in-onecrmcrm-systememaillinearmcpmessagingnotesnotionofficerustslackslack-alternativestartupstartup-toolstypescriptworkspace
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.jsonindex 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.lockindex 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.tomlindex 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.rsindex 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 pinssqlx::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 historysqlx::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 documentsqlx::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 permissioncreate::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.rsindex 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.rsindex 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: Poolassert!(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.rsindex 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 pinssqlx::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 historysqlx::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 presentlet 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 permissionsqlx::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 documentsqlx::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.rsindex 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 documentlet 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(())+ }}