fix: drop request deduper, sqlite dulicated write, add more tracing::debug

Author: GreyElaina

core/src/db/postgres/comment_attachment_repo.rs

@@ -33,9 +33,7 @@ impl PostgresCommentAttachmentRepository {
             mime: row.get("mime"),
             size: row.get("size"),
             created_at,
-            created_by: row
-                .get::<Option<String>, _>("created_by")
-                .map(UserId::from),
+            created_by: row.get::<Option<String>, _>("created_by").map(UserId::from),
         }
     }
 }

core/src/db/rocks/doc_role_backend.rs

@@ -182,8 +182,11 @@ impl DocRoleBackend for RocksDocRoleBackend {
 
         let mut batch = WriteBatch::default();
         for role in roles {
-            let key =
-                Self::role_key(role.workspace_id.as_str(), role.doc_id.as_str(), role.user_id.as_str());
+            let key = Self::role_key(
+                role.workspace_id.as_str(),
+                role.doc_id.as_str(),
+                role.user_id.as_str(),
+            );
             let value = Self::encode_record(role)?;
             batch.put_cf(self.store.doc_roles_cf(), key.as_bytes(), &value);
         }

core/src/db/sqlite/comment_attachment_repo.rs

@@ -33,9 +33,7 @@ impl SqliteCommentAttachmentRepository {
             mime: row.get("mime"),
             size: row.get("size"),
             created_at,
-            created_by: row
-                .get::<Option<String>, _>("created_by")
-                .map(UserId::from),
+            created_by: row.get::<Option<String>, _>("created_by").map(UserId::from),
         }
     }
 }

core/src/db/sqlite/doc_update_log_store.rs

@@ -43,7 +43,27 @@ impl SqliteDocUpdateLogStore {
     }
 
     pub fn uses_external_storage(&self) -> bool {
-        self.payloads.uses_external_storage()
+        // NOTE:
+        //   For the SQLite backend we always store doc update payloads inline in the
+        //   `doc_updates.update_blob` column, even if a `DocDataBackend` is configured.
+        //
+        //   When `DocDataBackend::Sqlite` is used, the doc-data store shares the same
+        //   underlying SQLite database and connection pool as the main repositories.
+        //   Treating it as an "external" log store would cause `insert_updates` to:
+        //
+        //     1. Insert a row into `doc_updates` inside a transaction, then
+        //     2. Call `payloads.put_external`, which issues another `UPDATE doc_updates`
+        //        through the pool on a separate connection while the first transaction
+        //        still holds a write lock.
+        //
+        //   This easily leads to `SQLITE_BUSY` / "database is locked" errors and surfaces
+        //   as `failed to store doc update log payload for key log:<id>` during
+        //   `space:push-doc-update`.
+        //
+        //   Only the Rocks-backed `DocDataBackend` should be used for truly external
+        //   log payload storage. For SQLite we disable external payloads here so that
+        //   doc updates are kept inline and written once per row.
+        false
     }
 
     pub async fn insert_updates(

core/src/search.rs

@@ -67,9 +67,6 @@ mod tests {
     fn builder_api() {
         let query = SearchQuery::new("affine").with_workspace(WorkspaceId::from("workspace"));
         assert_eq!(query.term, "affine");
-        assert_eq!(
-            query.workspace_ids,
-            &[WorkspaceId::from("workspace")]
-        );
+        assert_eq!(query.workspace_ids, &[WorkspaceId::from("workspace")]);
     }
 }

server/src/comment/notifications.rs

@@ -45,9 +45,7 @@ pub async fn notify_comment_reply(
     let mut notify_ids =
         collect_workspace_owner_target(state, actor_id, comment, &mention_ids).await?;
 
-    if comment.author_id.as_str() != actor_id
-        && !mention_ids.contains(comment.author_id.as_str())
-    {
+    if comment.author_id.as_str() != actor_id && !mention_ids.contains(comment.author_id.as_str()) {
         notify_ids.insert(comment.author_id.clone());
     }
 

server/src/doc/cache.rs

@@ -576,6 +576,14 @@ impl DocCache {
         space_id: &str,
         doc_id: &str,
     ) -> DocCacheResult<(Vec<u8>, i64)> {
+        debug!(
+            space_type = ?space_type,
+            space_id,
+            doc_id,
+            mode = ?self.mode,
+            "doc cache snapshot requested"
+        );
+
         if let DocCacheMode::Bypass = self.mode {
             return match space_type {
                 SpaceType::Workspace => {

server/src/doc/sync.rs

@@ -144,6 +144,15 @@ pub async fn apply_doc_updates<S>(
 where
     S: DocUpdateState,
 {
+    tracing::debug!(
+        ?space_type,
+        workspace_id = workspace_id,
+        doc_id = doc_id,
+        update_count = updates.len(),
+        has_editor = context.editor_id.is_some(),
+        "apply_doc_updates starting"
+    );
+
     let cache_result = state
         .doc_cache()
         .apply_updates(
@@ -156,6 +165,14 @@ where
         .await
         .map_err(AppError::from_anyhow)?;
 
+    tracing::debug!(
+        ?space_type,
+        workspace_id = workspace_id,
+        doc_id = doc_id,
+        timestamp = cache_result.timestamp,
+        "apply_doc_updates cache apply complete"
+    );
+
     let channel_key = doc_channel_key(workspace_id, doc_id);
     let meta = SocketBroadcastMeta::new(
         space_type,

server/src/graphql/user.rs

@@ -285,7 +285,7 @@ mod tests {
         testing::{insert_document, seed_workspace, setup_state},
     };
     use async_graphql::{Request as GraphQLRequest, Value as GraphQLValue};
-use barffine_core::{ids::UserId, notification::NotificationRecord};
+    use barffine_core::{ids::UserId, notification::NotificationRecord};
     use chrono::{Duration, Utc};
     use serde_json::json;
     use uuid::Uuid;

server/src/socket/auth.rs

@@ -19,9 +19,7 @@ use crate::{
     state::{AppState, SocketRuntimeState},
 };
 
-pub(crate) fn build_socket(
-    runtime: Arc<SocketRuntimeState>,
-) -> (SocketIoLayer, SocketIo) {
+pub(crate) fn build_socket(runtime: Arc<SocketRuntimeState>) -> (SocketIoLayer, SocketIo) {
     SocketIo::builder()
         .with_state(runtime.clone())
         .max_payload(100_000_000)