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 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.rs
index 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 set
let 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.rs
index 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.rs
index 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 creator
upsert_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.rs
new file mode 100644
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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,