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 created outside the documents repo (#6478)
Will Hutchinson15174cef63a1
diff --git a/crates/documents/src/outbound/pg_document_repo/tests.rs b/crates/documents/src/outbound/pg_document_repo/tests.rsindex 7812e3bff3..600f2d7fa9 100644--- a/crates/documents/src/outbound/pg_document_repo/tests.rs+++ b/crates/documents/src/outbound/pg_document_repo/tests.rs@@ -764,20 +764,33 @@ async fn test_get_basic_document(pool: Pool<Postgres>) {)]async fn test_soft_delete_document(pool: Pool<Postgres>) {let repo = PgDocumentRepo::new(pool.clone());+ let document_id = TEST_DOCUMENT_ID;+ let mut transaction = pool.begin().await.unwrap();+ entity_registry_db_utils::insert_entity(+ &mut transaction,+ entity_registry_db_utils::NewEntityRecord::new(+ uuid::Uuid::parse_str(document_id).unwrap(),+ entity_registry_db_utils::RegisteredEntityType::Document,+ model_owner::Owner::User(user_id(TEST_DOCUMENT_OWNER_ID)),+ ),+ )+ .await+ .unwrap();+ transaction.commit().await.unwrap();- repo.soft_delete_document("d0000000-0000-0000-0000-000000000001")- .await- .unwrap();+ repo.soft_delete_document(document_id).await.unwrap();- // Verify deleted_at is setlet row = sqlx::query!(r#"SELECT "deletedAt"::timestamptz as deleted_at FROM "Document" WHERE id = $1"#,- "d0000000-0000-0000-0000-000000000001"+ document_id).fetch_one(&pool).await.unwrap();assert!(row.deleted_at.is_some());++ let entity = fetch_entity_row(&pool, document_id).await;+ assert!(entity.deleted_at.is_some());}#[sqlx::test(@@ -1831,6 +1844,31 @@ async fn test_deleting_document_cascades_team_task_row(pool: Pool<Postgres>) {assert_eq!(count, 0);}+#[sqlx::test(+ migrator = "MACRO_DB_MIGRATIONS",+ fixtures(path = "../../../fixtures", scripts("documents_test_data"))+)]+async fn test_delete_document_by_id_removes_entity_row(pool: Pool<Postgres>) {+ let repo = PgDocumentRepo::new(pool.clone());+ let document_id = TEST_DOCUMENT_ID;+ let mut transaction = pool.begin().await.unwrap();+ entity_registry_db_utils::insert_entity(+ &mut transaction,+ entity_registry_db_utils::NewEntityRecord::new(+ uuid::Uuid::parse_str(document_id).unwrap(),+ entity_registry_db_utils::RegisteredEntityType::Document,+ model_owner::Owner::User(user_id(TEST_DOCUMENT_OWNER_ID)),+ ),+ )+ .await+ .unwrap();+ transaction.commit().await.unwrap();++ repo.delete_document_by_id(document_id).await.unwrap();++ assert_eq!(count_entity_rows_for_id(&pool, document_id).await, 0);+}+#[sqlx::test(migrator = "MACRO_DB_MIGRATIONS",fixtures(path = "../../../fixtures", scripts("documents_test_data"))diff --git a/crates/macro_db_client/src/document/delete_document.rs b/crates/macro_db_client/src/document/delete_document.rsindex 628331e142..405631e014 100644--- a/crates/macro_db_client/src/document/delete_document.rs+++ b/crates/macro_db_client/src/document/delete_document.rs@@ -122,15 +122,20 @@ pub async fn delete_document_bulk_tsx(.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_ids- .iter()- .filter_map(|p| macro_uuid::string_to_uuid(p).ok())- .collect::<Vec<uuid::Uuid>>(),+ &document_uuids,EntityType::Document,).await?;+ for document_uuid in document_uuids {+ entity_registry_db_utils::delete_entity(transaction, document_uuid).await?;+ }Ok(())}diff --git a/crates/macro_db_client/src/document/initialize_onboarding_documents.rs b/crates/macro_db_client/src/document/initialize_onboarding_documents.rsindex 1b4f6f1559..a4d1e1457d 100644--- a/crates/macro_db_client/src/document/initialize_onboarding_documents.rs+++ b/crates/macro_db_client/src/document/initialize_onboarding_documents.rs@@ -144,6 +144,7 @@ pub async fn create_onboarding_documents(for document_id in &document_ids {create_document_permission(transaction, document_id, share_permission).await?;+ register_owned_document(transaction, document_id, user_id.copied()).await?;}let mut documents = Vec::new();@@ -216,6 +217,7 @@ pub async fn create_onboarding_docx(// Add item to user history for creatorupsert_user_history(transaction, user_id.copied(), &document.id, "document").await?;+ register_owned_document(transaction, &document.id, user_id.copied()).await?;Ok(BasicDocument {document_id: document.id,@@ -234,3 +236,32 @@ pub async fn create_onboarding_docx(sub_type: None,})}++async fn register_owned_document(+ transaction: &mut Transaction<'_, Postgres>,+ document_id: &str,+ user_id: MacroUserIdStr<'_>,+) -> anyhow::Result<()> {+ let document_uuid = macro_uuid::string_to_uuid(document_id)?;+ let owner = model_owner::Owner::User(user_id.copied().into_owned());+ entity_registry_db_utils::insert_entity(+ transaction,+ entity_registry_db_utils::NewEntityRecord::new(+ document_uuid,+ entity_registry_db_utils::RegisteredEntityType::Document,+ owner.clone(),+ ),+ )+ .await?;+ entity_access_db_utils::upsert_owner_grant(+ transaction,+ &document_uuid,+ EntityType::Document,+ &owner,+ )+ .await?;+ Ok(())+}++#[cfg(test)]+mod test;diff --git a/crates/macro_db_client/src/document/initialize_onboarding_documents/test.rs b/crates/macro_db_client/src/document/initialize_onboarding_documents/test.rsnew file mode 100644index 0000000000..41d15ed217--- /dev/null+++ b/crates/macro_db_client/src/document/initialize_onboarding_documents/test.rs@@ -0,0 +1,119 @@+use super::*;+use macro_user_id::cowlike::CowLike;+use macro_user_id::user_id::MacroUserIdStr;+use model::document::SaveBomPart;+use models_permissions::share_permission::SharePermissionV2;+use sqlx::{Pool, Postgres, Row};++const USER_ID: &str = "macro|[email protected]";++async fn assert_owned_document_rows(+ pool: &Pool<Postgres>,+ document_id: &str,+) -> anyhow::Result<()> {+ let document_uuid = macro_uuid::string_to_uuid(document_id)?;+ let entity = sqlx::query(+ r#"+ SELECT+ owner_type::text AS owner_type,+ owner_id,+ entity_type,+ deleted_at+ FROM entity+ WHERE id = $1+ "#,+ )+ .bind(document_uuid)+ .fetch_one(pool)+ .await?;+ assert_eq!(entity.get::<String, _>("owner_type"), "user");+ assert_eq!(entity.get::<String, _>("owner_id"), USER_ID);+ assert_eq!(entity.get::<String, _>("entity_type"), "document");+ assert_eq!(+ entity.get::<Option<chrono::DateTime<chrono::Utc>>, _>("deleted_at"),+ None+ );++ let access_level: String = sqlx::query_scalar(+ r#"+ SELECT access_level::text+ FROM entity_access+ WHERE entity_id = $1+ AND source_id = $2+ AND granted_from_project_id IS NULL+ "#,+ )+ .bind(document_uuid)+ .bind(USER_ID)+ .fetch_one(pool)+ .await?;+ assert_eq!(access_level, "owner");+ Ok(())+}++#[sqlx::test(fixtures(path = "../../../fixtures", scripts("basic_user_with_documents")))]+async fn create_onboarding_documents_registers_entity_and_owner_grant(+ pool: Pool<Postgres>,+) -> anyhow::Result<()> {+ let user_id = MacroUserIdStr::parse_from_str(USER_ID)?.into_owned();+ let share_permission = SharePermissionV2::new_project_share_permission(None);++ let mut transaction = pool.begin().await?;+ let project = create_project_transaction(+ &mut transaction,+ user_id.copied(),+ "Starter Docs",+ None,+ &share_permission,+ )+ .await?;+ let documents = create_onboarding_documents(+ &mut transaction,+ user_id.clone(),+ &project.id,+ &share_permission,+ vec![("Alpha".into(), "md".into()), ("Beta".into(), "pdf".into())],+ )+ .await?;+ transaction.commit().await?;++ assert_eq!(documents.len(), 2);+ for document in &documents {+ assert_owned_document_rows(&pool, &document.document_id).await?;+ }+ Ok(())+}++#[sqlx::test(fixtures(path = "../../../fixtures", scripts("basic_user_with_documents")))]+async fn create_onboarding_docx_registers_entity_and_owner_grant(+ pool: Pool<Postgres>,+) -> anyhow::Result<()> {+ let user_id = MacroUserIdStr::parse_from_str(USER_ID)?.into_owned();+ let share_permission = SharePermissionV2::new_project_share_permission(None);++ let mut transaction = pool.begin().await?;+ let project = create_project_transaction(+ &mut transaction,+ user_id.copied(),+ "Starter Docs",+ None,+ &share_permission,+ )+ .await?;+ let document = create_onboarding_docx(+ &mut transaction,+ user_id.clone(),+ &project.id,+ &share_permission,+ "Onboarding Docx",+ vec![SaveBomPart {+ sha: "sha".into(),+ path: "path".into(),+ }],+ )+ .await?;+ transaction.commit().await?;++ assert_owned_document_rows(&pool, &document.document_id).await?;+ Ok(())+}diff --git a/crates/macro_db_client/src/document/v2/create.rs b/crates/macro_db_client/src/document/v2/create.rsindex 20edf3dd00..553be213b3 100644--- a/crates/macro_db_client/src/document/v2/create.rs+++ b/crates/macro_db_client/src/document/v2/create.rs@@ -38,7 +38,6 @@ pub struct CreateDocumentArgs<'a> {}/// Creates a new document-/// NOTE: this is only used in seed_cli at the moment and needs to be deprecated#[instrument(skip(db))]pub async fn create_document(db: &Pool<Postgres>,@@ -219,6 +218,15 @@ pub async fn create_document_txn(AccessLevel::Owner,).await?;+ entity_registry_db_utils::insert_entity(+ transaction,+ entity_registry_db_utils::NewEntityRecord::new(+ macro_uuid::string_to_uuid(&document_id)?,+ entity_registry_db_utils::RegisteredEntityType::Document,+ model_owner::Owner::User(user_id.clone()),+ ),+ )+ .await?;if let Some(attachment) = email_attachment_id {crate::document::document_email::create_document_email_record(diff --git a/crates/macro_db_client/src/instructions/create.rs b/crates/macro_db_client/src/instructions/create.rsindex bdbef89193..52a71ec1f5 100644--- a/crates/macro_db_client/src/instructions/create.rs+++ b/crates/macro_db_client/src/instructions/create.rs@@ -1,4 +1,7 @@-use crate::{document::v2::create::create_document, instructions::get::get_instructions_document};+use crate::{+ document::v2::create::{CreateDocumentArgs, create_document_txn},+ instructions::get::get_instructions_document,+};use macro_user_id::{cowlike::CowLike, user_id::MacroUserIdStr};use model::document::FileType;use models_dcs::constants::INSTRUCTIONS_FILE_NAME;@@ -21,9 +24,54 @@ pub async fn create_instructions_document() -> Result<String, CreateInstructionsError> {tracing::trace!("creating instructions document");- let document_metadata = create_document(- db,- crate::document::v2::create::CreateDocumentArgs {+ let mut cleared_stale_mapping = false;+ loop {+ match create_instructions_document_once(db, user_id.clone()).await {+ Ok(document_id) => return Ok(document_id),+ Err(CreateInstructionsError::UserAlreadyHasInstructions) => {+ let exists = get_instructions_document(db, user_id.copied())+ .await+ .map(|doc_id| doc_id.is_some())?;+ if exists {+ return Err(CreateInstructionsError::UserAlreadyHasInstructions);+ }+ if cleared_stale_mapping {+ return Err(CreateInstructionsError::UserAlreadyHasInstructions);+ }++ sqlx::query!(+ r#"DELETE FROM "InstructionsDocuments" WHERE "userId" = $1"#,+ user_id.as_ref()+ )+ .execute(db)+ .await+ .map_err(|e| {+ CreateInstructionsError::DatabaseError(anyhow::anyhow!(+ "unable to delete instructions document: {}",+ e+ ))+ })?;+ cleared_stale_mapping = true;+ }+ Err(err) => return Err(err),+ }+ }+}++#[instrument(skip(db))]+async fn create_instructions_document_once(+ db: &sqlx::Pool<sqlx::Postgres>,+ user_id: MacroUserIdStr<'static>,+) -> Result<String, CreateInstructionsError> {+ let mut transaction = db.begin().await.map_err(|error| {+ CreateInstructionsError::DatabaseError(anyhow::anyhow!(+ "unable to create transaction: {error}"+ ))+ })?;++ let document_metadata = create_document_txn(+ &mut transaction,+ CreateDocumentArgs {id: None,sha: "",document_name: INSTRUCTIONS_FILE_NAME,@@ -44,48 +92,25 @@ pub async fn create_instructions_document(},).await?;-let document_id = document_metadata.document_id;- let insert_result = insert_instructions_document(db, user_id.copied(), &document_id).await;-- match insert_result {- Ok(_) => (),- Err(err) => {- match err {- CreateInstructionsError::UserAlreadyHasInstructions => {- // Check if the instructions document has been deleted but the instructions table row still exists- let exists = get_instructions_document(db, user_id.copied())- .await- .map(|doc_id| doc_id.is_some())?;-- // If the instructions document exists, we can't create a new one- if exists {- return Err(CreateInstructionsError::UserAlreadyHasInstructions);- }-- // Otherwise we can safely delete the instructions row- sqlx::query!(- r#"DELETE FROM "InstructionsDocuments" WHERE "userId" = $1"#,- user_id.as_ref()- )- .execute(db)- .await- .map_err(|e| {- CreateInstructionsError::DatabaseError(anyhow::anyhow!(- "unable to delete instructions document: {}",- e- ))- })?;-- // try again- insert_instructions_document(db, user_id, &document_id).await?;- }- _ => return Err(err),- }+ if let Err(err) =+ insert_instructions_document_on(&mut *transaction, user_id.copied(), &document_id).await+ {+ if let Err(rollback_err) = transaction.rollback().await {+ return Err(CreateInstructionsError::DatabaseError(anyhow::anyhow!(+ "unable to roll back instructions document create after {err}: {rollback_err}"+ )));}+ return Err(err);}+ transaction.commit().await.map_err(|error| {+ CreateInstructionsError::DatabaseError(anyhow::anyhow!(+ "unable to commit instructions document create: {error}"+ ))+ })?;+Ok(document_id)}@@ -96,6 +121,18 @@ pub async fn insert_instructions_document(user_id: MacroUserIdStr<'_>,document_id: &str,) -> Result<(), CreateInstructionsError> {+ insert_instructions_document_on(db, user_id, document_id).await+}++#[instrument(skip(db))]+async fn insert_instructions_document_on<'e, E>(+ db: E,+ user_id: MacroUserIdStr<'_>,+ document_id: &str,+) -> Result<(), CreateInstructionsError>+where+ E: sqlx::PgExecutor<'e>,+{tracing::trace!("inserting instructions document");let result = sqlx::query!(@@ -134,7 +171,7 @@ pub async fn insert_instructions_document(#[cfg(test)]mod tests {use super::*;- use sqlx::{Pool, Postgres};+ use sqlx::{Pool, Postgres, Row};#[sqlx::test(fixtures(path = "../../fixtures", scripts("basic_user_with_documents")))]async fn test_create_instructions_document_success(pool: Pool<Postgres>) -> anyhow::Result<()> {@@ -169,6 +206,28 @@ mod tests {assert_eq!(document.file_type.as_deref(), Some("md"));assert_eq!(document.owner.as_str(), user_id.as_ref());+ let entity = sqlx::query(+ r#"+ SELECT+ owner_type::text AS owner_type,+ owner_id,+ entity_type,+ deleted_at+ FROM entity+ WHERE id = $1+ "#,+ )+ .bind(macro_uuid::string_to_uuid(&document_id)?)+ .fetch_one(&pool)+ .await?;+ assert_eq!(entity.get::<String, _>("owner_type"), "user");+ assert_eq!(entity.get::<String, _>("owner_id"), user_id.as_ref());+ assert_eq!(entity.get::<String, _>("entity_type"), "document");+ assert_eq!(+ entity.get::<Option<chrono::DateTime<chrono::Utc>>, _>("deleted_at"),+ None+ );+Ok(())}Err(e) => panic!("Expected success but got error: {:?}", e),@@ -181,30 +240,93 @@ mod tests {) -> anyhow::Result<()> {let user_id = MacroUserIdStr::parse_from_str("macro|[email protected]").unwrap();- // First creation should succeed- let result1 = create_instructions_document(&pool, user_id.clone()).await;- match result1 {- Ok(document_id) => {- // Verify the document exists- assert!(!document_id.is_empty());- }- Err(e) => panic!("First creation should succeed but got: {:?}", e),- }-- // Second creation should fail with UserAlreadyHasInstructions- let result2 = create_instructions_document(&pool, user_id).await;+ let first_id = create_instructions_document(&pool, user_id.clone())+ .await+ .expect("first creation should succeed");+ assert!(!first_id.is_empty());+ let result2 = create_instructions_document(&pool, user_id.clone()).await;match result2 {- Err(CreateInstructionsError::UserAlreadyHasInstructions) => {- // This is expected- Ok(())- }+ Err(CreateInstructionsError::UserAlreadyHasInstructions) => {}Err(e) => panic!("Expected UserAlreadyHasInstructions but got: {:?}", e),Ok(document_id) => panic!("Expected error but got success with document_id: {}",document_id),}++ let documents = sqlx::query!(+ r#"SELECT id FROM "Document" WHERE owner = $1 AND name = $2"#,+ user_id.as_ref(),+ INSTRUCTIONS_FILE_NAME,+ )+ .fetch_all(&pool)+ .await?;+ assert_eq!(documents.len(), 1);+ assert_eq!(documents[0].id, first_id);++ let entity_count: i64 = sqlx::query_scalar(+ r#"+ SELECT COUNT(*)+ FROM entity+ WHERE owner_id = $1+ AND entity_type = 'document'+ AND id = $2+ "#,+ )+ .bind(user_id.as_ref())+ .bind(macro_uuid::string_to_uuid(&first_id)?)+ .fetch_one(&pool)+ .await?;+ assert_eq!(entity_count, 1);+ Ok(())+ }++ #[sqlx::test(fixtures(path = "../../fixtures", scripts("basic_user_with_documents")))]+ async fn test_create_instructions_document_replaces_stale_mapping(+ pool: Pool<Postgres>,+ ) -> anyhow::Result<()> {+ let user_id = MacroUserIdStr::parse_from_str("macro|[email protected]").unwrap();+ let stale_id = create_instructions_document(&pool, user_id.clone())+ .await+ .expect("first creation should succeed");++ sqlx::query!(+ r#"UPDATE "Document" SET "deletedAt" = NOW() WHERE id = $1"#,+ stale_id+ )+ .execute(&pool)+ .await?;++ let replacement_id = create_instructions_document(&pool, user_id.clone())+ .await+ .expect("stale mapping should be replaced");+ assert_ne!(replacement_id, stale_id);++ let mapping = sqlx::query!(+ r#"SELECT "documentId" as "document_id" FROM "InstructionsDocuments" WHERE "userId" = $1"#,+ user_id.as_ref()+ )+ .fetch_one(&pool)+ .await?;+ assert_eq!(mapping.document_id, replacement_id);++ let live_documents = sqlx::query!(+ r#"+ SELECT id+ FROM "Document"+ WHERE owner = $1+ AND name = $2+ AND "deletedAt" IS NULL+ "#,+ user_id.as_ref(),+ INSTRUCTIONS_FILE_NAME,+ )+ .fetch_all(&pool)+ .await?;+ assert_eq!(live_documents.len(), 1);+ assert_eq!(live_documents[0].id, replacement_id);+ Ok(())}#[sqlx::test(fixtures(path = "../../fixtures", scripts("basic_user_with_documents")))]diff --git a/crates/macro_db_client/src/user/delete_user_dss_items/delete_documents.rs b/crates/macro_db_client/src/user/delete_user_dss_items/delete_documents.rsindex 5da1e0876c..61d056cfcf 100644--- a/crates/macro_db_client/src/user/delete_user_dss_items/delete_documents.rs+++ b/crates/macro_db_client/src/user/delete_user_dss_items/delete_documents.rs@@ -63,6 +63,13 @@ pub async fn delete_user_documents(.execute(transaction.as_mut()).await?;+ for document_id in &user_documents {+ let Ok(document_uuid) = macro_uuid::string_to_uuid(document_id) else {+ continue;+ };+ entity_registry_db_utils::delete_entity(transaction, document_uuid).await?;+ }+Ok(user_documents)}diff --git a/crates/projects/src/outbound/pg_project_repo/tests.rs b/crates/projects/src/outbound/pg_project_repo/tests.rsindex a8e0054ddf..3e47600d6f 100644--- a/crates/projects/src/outbound/pg_project_repo/tests.rs+++ b/crates/projects/src/outbound/pg_project_repo/tests.rs@@ -797,6 +797,10 @@ async fn upload_folder_preserves_tree_metadata_and_compensates(assert_eq!(entity.owner_id, "macro|[email protected]");assert_eq!(entity.entity_type, "project");}+ let document_entity = fetch_entity_row(&pool, &result.documents[0].document_id).await;+ assert_eq!(document_entity.owner_type, "user");+ assert_eq!(document_entity.owner_id, "macro|[email protected]");+ assert_eq!(document_entity.entity_type, "document");repo.delete_uploaded_tree(&result.project_ids, &document_ids).await?;@@ -818,6 +822,7 @@ async fn upload_folder_preserves_tree_metadata_and_compensates(count_entity_rows_for_ids(&pool, &result.project_ids).await,0);+ assert_eq!(count_entity_rows_for_ids(&pool, &document_ids).await, 0);Ok(())}diff --git a/crates/projects/src/outbound/pg_project_repo/upload_folder.rs b/crates/projects/src/outbound/pg_project_repo/upload_folder.rsindex c865300037..96fd588a88 100644--- a/crates/projects/src/outbound/pg_project_repo/upload_folder.rs+++ b/crates/projects/src/outbound/pg_project_repo/upload_folder.rs@@ -250,6 +250,16 @@ async fn create_empty_document(AccessLevel::Owner,).await?;+ entity_registry_db_utils::insert_entity(+ transaction,+ entity_registry_db_utils::NewEntityRecord::new(+ entity_id,+ entity_registry_db_utils::RegisteredEntityType::Document,+ model_owner::Owner::User(user_id.clone()),+ ),+ )+ .await+ .map_err(|error| sqlx::Error::Protocol(error.to_string()))?;Ok(DocumentMetadata::new_document(&document.id,