Merge pull request #1544 from AppFlowy-IO/endpoint-to-check-whether-row-document-collab-exists

feat: endpoint to check whether row document collab exists

Author: khorshuheng

.sqlx/query-6fbcd1c32c638530461c74f8c8195a5b1e1e6f7a389a6a60d889c88c5f47302a.json

@@ -12,9 +12,10 @@ use client_api_entity::workspace_dto::{
   ListDatabaseRowUpdatedParam, UpsertDatatabaseRow,
 };
 use client_api_entity::{
-  AFCollabEmbedInfo, BatchQueryCollabParams, BatchQueryCollabResult, CollabParams,
-  CreateCollabData, CreateCollabParams, DeleteCollabParams, PublishCollabItem, QueryCollab,
-  QueryCollabParams, RepeatedAFCollabEmbedInfo, UpdateCollabWebParams,
+  AFCollabEmbedInfo, AFDatabaseRowDocumentCollabExistenceInfo, BatchQueryCollabParams,
+  BatchQueryCollabResult, CollabParams, CreateCollabData, CreateCollabParams, DeleteCollabParams,
+  PublishCollabItem, QueryCollab, QueryCollabParams, RepeatedAFCollabEmbedInfo,
+  UpdateCollabWebParams,
 };
 use collab_rt_entity::collab_proto::{CollabDocStateParams, PayloadCompressionType};
 use collab_rt_entity::HttpRealtimeMessage;
@@ -430,6 +431,24 @@ impl Client {
     process_response_error(resp).await
   }
 
+  pub async fn check_if_row_document_collab_exists(
+    &self,
+    workspace_id: &Uuid,
+    object_id: &Uuid,
+  ) -> Result<bool, AppResponseError> {
+    let url = format!(
+      "{}/api/workspace/{workspace_id}/collab/{object_id}/row-document-collab-exists",
+      self.base_url
+    );
+    let resp = self
+      .http_client_with_auth(Method::GET, &url)
+      .await?
+      .send()
+      .await?;
+    let info = process_response_data::<AFDatabaseRowDocumentCollabExistenceInfo>(resp).await?;
+    Ok(info.exists)
+  }
+
   pub async fn get_collab_embed_info(
     &self,
     workspace_id: &Uuid,

libs/client-api/src/http_collab.rs

@@ -452,6 +452,11 @@ pub struct QueryWorkspaceMember {
   pub uid: i64,
 }
 
+#[derive(Debug, Serialize, Deserialize)]
+pub struct AFDatabaseRowDocumentCollabExistenceInfo {
+  pub exists: bool,
+}
+
 #[derive(Debug, Serialize, Deserialize)]
 pub struct AFCollabEmbedInfo {
   pub object_id: Uuid,

libs/database-entity/src/dto.rs

@@ -230,6 +230,24 @@ where
   Ok(records)
 }
 
+pub async fn select_collab_id_exists<'a, E>(conn: E, object_id: &Uuid) -> Result<bool, sqlx::Error>
+where
+  E: Executor<'a, Database = Postgres>,
+{
+  let exists = sqlx::query_scalar!(
+    r#"
+        SELECT EXISTS (
+            SELECT 1 FROM af_collab
+            WHERE oid = $1 AND deleted_at IS NULL
+        )
+        "#,
+    object_id,
+  )
+  .fetch_one(conn)
+  .await?;
+  Ok(exists.unwrap_or(false))
+}
+
 #[inline]
 pub async fn select_blob_from_af_collab<'a, E>(
   conn: E,

libs/database/src/collab/collab_db_ops.rs

@@ -3,6 +3,7 @@ use crate::api::util::{compress_type_from_header_value, device_id_from_headers};
 use crate::api::ws::RealtimeServerAddr;
 use crate::biz;
 use crate::biz::authentication::jwt::{Authorization, OptionalUserUuid, UserUuid};
+use crate::biz::collab::database::check_if_row_document_collab_exists;
 use crate::biz::collab::ops::{
   get_user_favorite_folder_views, get_user_recent_folder_views, get_user_trash_folder_views,
 };
@@ -184,6 +185,10 @@ pub fn workspace_scope() -> Scope {
       web::resource("/v1/{workspace_id}/collab/{object_id}/web-update")
         .route(web::post().to(post_web_update_handler)),
     )
+    .service(
+      web::resource("/{workspace_id}/collab/{object_id}/row-document-collab-exists")
+          .route(web::get().to(get_row_document_collab_exists_handler)),
+    )
     .service(
       web::resource("/{workspace_id}/collab/{object_id}/embed-info")
         .route(web::get().to(get_collab_embed_info_handler)),
@@ -1350,6 +1355,28 @@ async fn post_web_update_handler(
   Ok(Json(AppResponse::Ok()))
 }
 
+#[instrument(level = "debug", skip_all)]
+async fn get_row_document_collab_exists_handler(
+  user_uuid: UserUuid,
+  path: web::Path<(Uuid, Uuid)>,
+  state: Data<AppState>,
+) -> Result<Json<AppResponse<AFDatabaseRowDocumentCollabExistenceInfo>>> {
+  let uid = state
+    .user_cache
+    .get_user_uid(&user_uuid)
+    .await
+    .map_err(AppResponseError::from)?;
+  let (workspace_id, object_id) = path.into_inner();
+  state
+    .collab_access_control
+    .enforce_action(&workspace_id, &uid, &object_id, Action::Read)
+    .await?;
+  let exists = check_if_row_document_collab_exists(&state.pg_pool, &object_id).await?;
+  Ok(Json(AppResponse::Ok().with_data(
+    AFDatabaseRowDocumentCollabExistenceInfo { exists },
+  )))
+}
+
 async fn post_space_handler(
   user_uuid: UserUuid,
   path: web::Path<Uuid>,

src/api/workspace.rs

@@ -5,7 +5,7 @@ use app_error::AppError;
 use async_trait::async_trait;
 use collab::lock::RwLock;
 use collab_database::database_trait::{DatabaseCollabReader, EncodeCollabByOid};
-use collab_database::rows::{DatabaseRow, RowId};
+use collab_database::rows::{meta_id_from_row_id, DatabaseRow, RowId, RowMetaKey};
 use collab_database::{
   database::{gen_database_group_id, gen_field_id},
   entity::FieldType,
@@ -21,7 +21,8 @@ use collab_database::{
 };
 use collab_entity::{CollabType, EncodedCollab};
 use dashmap::DashMap;
-use database::collab::{CollabStore, GetCollabOrigin};
+use database::collab::{select_collab_id_exists, CollabStore, GetCollabOrigin};
+use sqlx::PgPool;
 use uuid::Uuid;
 use yrs::block::ClientID;
 
@@ -167,6 +168,17 @@ fn create_card_status_field() -> Field {
     .with_type_option_data(field_type, default_select_type_option.into())
 }
 
+pub async fn check_if_row_document_collab_exists(
+  pg_pool: &PgPool,
+  row_id: &Uuid,
+) -> Result<bool, AppError> {
+  let row_document_collab_id = meta_id_from_row_id(row_id, RowMetaKey::DocumentId);
+  let row_document_collab_id = Uuid::parse_str(&row_document_collab_id)
+    .map_err(|_| AppError::Internal(anyhow::anyhow!("Invalid row document collab ID")))?;
+  let exists = select_collab_id_exists(pg_pool, &row_document_collab_id).await?;
+  Ok(exists)
+}
+
 #[derive(Clone)]
 pub struct PostgresDatabaseCollabService {
   pub workspace_id: Uuid,

src/biz/collab/database.rs

@@ -37,6 +37,12 @@ async fn database_row_upsert_with_doc() {
       row_detail.doc,
       Some(String::from("This is a document of a database row"))
     );
+    let row_uuid = uuid::Uuid::parse_str(&row_id).unwrap();
+    let row_collab_doc_exists = &c
+      .check_if_row_document_collab_exists(&workspace_id, &row_uuid)
+      .await
+      .unwrap();
+    assert!(row_collab_doc_exists)
   }
   // Upsert row with another doc
   let _ = c