chore: reanme some structs

frontend/rust-lib/flowy-document/src/editor.rs

@@ -6,14 +6,17 @@ use crate::{
 };
 use bytes::Bytes;
 use flowy_error::{internal_error, FlowyResult};
-use flowy_revision::{RevisionCloudService, RevisionManager, RevisionObjectBuilder, RevisionWebSocket};
+use flowy_revision::{
+    RevisionCloudService, RevisionCompress, RevisionManager, RevisionObjectDeserializer, RevisionObjectSerializer,
+    RevisionWebSocket,
+};
 use flowy_sync::entities::ws_data::ServerRevisionWSData;
 use flowy_sync::{
-    entities::{revision::Revision, text_block::DocumentPayloadPB},
+    entities::{document::DocumentPayloadPB, revision::Revision},
     errors::CollaborateResult,
     util::make_operations_from_revisions,
 };
-use lib_ot::core::AttributeEntry;
+use lib_ot::core::{AttributeEntry, AttributeHashMap};
 use lib_ot::{
     core::{DeltaOperation, Interval},
     text_delta::TextOperations,
@@ -40,13 +43,13 @@ impl DocumentEditor {
         rev_web_socket: Arc<dyn RevisionWebSocket>,
         cloud_service: Arc<dyn RevisionCloudService>,
     ) -> FlowyResult<Arc<Self>> {
-        let document_info = rev_manager.load::<DocumentRevisionBuilder>(Some(cloud_service)).await?;
-        let delta = document_info.delta()?;
+        let document_info = rev_manager.load::<DocumentRevisionSerde>(Some(cloud_service)).await?;
+        let operations = TextOperations::from_bytes(&document_info.content)?;
         let rev_manager = Arc::new(rev_manager);
         let doc_id = doc_id.to_string();
         let user_id = user.user_id()?;
 
-        let edit_cmd_tx = spawn_edit_queue(user, rev_manager.clone(), delta);
+        let edit_cmd_tx = spawn_edit_queue(user, rev_manager.clone(), operations);
         #[cfg(feature = "sync")]
         let ws_manager = crate::web_socket::make_document_ws_manager(
             doc_id.clone(),
@@ -225,11 +228,11 @@ impl DocumentEditor {
     }
 }
 
-struct DocumentRevisionBuilder();
-impl RevisionObjectBuilder for DocumentRevisionBuilder {
+pub struct DocumentRevisionSerde();
+impl RevisionObjectDeserializer for DocumentRevisionSerde {
     type Output = DocumentPayloadPB;
 
-    fn build_object(object_id: &str, revisions: Vec<Revision>) -> FlowyResult<Self::Output> {
+    fn deserialize_revisions(object_id: &str, revisions: Vec<Revision>) -> FlowyResult<Self::Output> {
         let (base_rev_id, rev_id) = revisions.last().unwrap().pair_rev_id();
         let mut delta = make_operations_from_revisions(revisions)?;
         correct_delta(&mut delta);
@@ -243,6 +246,20 @@ impl RevisionObjectBuilder for DocumentRevisionBuilder {
     }
 }
 
+impl RevisionObjectSerializer for DocumentRevisionSerde {
+    fn serialize_revisions(revisions: Vec<Revision>) -> FlowyResult<Bytes> {
+        let operations = make_operations_from_revisions::<AttributeHashMap>(revisions)?;
+        Ok(operations.json_bytes())
+    }
+}
+
+pub(crate) struct DocumentRevisionCompactor();
+impl RevisionCompress for DocumentRevisionCompactor {
+    fn serialize_revisions(&self, revisions: Vec<Revision>) -> FlowyResult<Bytes> {
+        DocumentRevisionSerde::serialize_revisions(revisions)
+    }
+}
+
 // quill-editor requires the delta should end with '\n' and only contains the
 // insert operation. The function, correct_delta maybe be removed in the future.
 fn correct_delta(delta: &mut TextOperations) {

frontend/rust-lib/flowy-document/src/event_handler.rs

@@ -1,14 +1,14 @@
 use crate::entities::{DocumentSnapshotPB, EditParams, EditPayloadPB, ExportDataPB, ExportParams, ExportPayloadPB};
-use crate::DocumentEditorManager;
+use crate::DocumentManager;
 use flowy_error::FlowyError;
-use flowy_sync::entities::text_block::DocumentIdPB;
+use flowy_sync::entities::document::DocumentIdPB;
 use lib_dispatch::prelude::{data_result, AppData, Data, DataResult};
 use std::convert::TryInto;
 use std::sync::Arc;
 
 pub(crate) async fn get_document_handler(
     data: Data<DocumentIdPB>,
-    manager: AppData<Arc<DocumentEditorManager>>,
+    manager: AppData<Arc<DocumentManager>>,
 ) -> DataResult<DocumentSnapshotPB, FlowyError> {
     let document_id: DocumentIdPB = data.into_inner();
     let editor = manager.open_document_editor(&document_id).await?;
@@ -21,7 +21,7 @@ pub(crate) async fn get_document_handler(
 
 pub(crate) async fn apply_edit_handler(
     data: Data<EditPayloadPB>,
-    manager: AppData<Arc<DocumentEditorManager>>,
+    manager: AppData<Arc<DocumentManager>>,
 ) -> Result<(), FlowyError> {
     let params: EditParams = data.into_inner().try_into()?;
     let _ = manager.apply_edit(params).await?;
@@ -31,7 +31,7 @@ pub(crate) async fn apply_edit_handler(
 #[tracing::instrument(level = "debug", skip(data, manager), err)]
 pub(crate) async fn export_handler(
     data: Data<ExportPayloadPB>,
-    manager: AppData<Arc<DocumentEditorManager>>,
+    manager: AppData<Arc<DocumentManager>>,
 ) -> DataResult<ExportDataPB, FlowyError> {
     let params: ExportParams = data.into_inner().try_into()?;
     let editor = manager.open_document_editor(&params.view_id).await?;

frontend/rust-lib/flowy-document/src/event_map.rs

@@ -1,11 +1,11 @@
 use crate::event_handler::*;
-use crate::DocumentEditorManager;
+use crate::DocumentManager;
 use flowy_derive::{Flowy_Event, ProtoBuf_Enum};
 use lib_dispatch::prelude::Module;
 use std::sync::Arc;
 use strum_macros::Display;
 
-pub fn create(document_manager: Arc<DocumentEditorManager>) -> Module {
+pub fn create(document_manager: Arc<DocumentManager>) -> Module {
     let mut module = Module::new().name(env!("CARGO_PKG_NAME")).data(document_manager);
 
     module = module

frontend/rust-lib/flowy-document/src/lib.rs

@@ -15,7 +15,7 @@ pub mod errors {
 pub const TEXT_BLOCK_SYNC_INTERVAL_IN_MILLIS: u64 = 1000;
 
 use crate::errors::FlowyError;
-use flowy_sync::entities::text_block::{CreateDocumentParams, DocumentIdPB, DocumentPayloadPB, ResetDocumentParams};
+use flowy_sync::entities::document::{CreateDocumentParams, DocumentIdPB, DocumentPayloadPB, ResetDocumentParams};
 use lib_infra::future::FutureResult;
 
 pub trait DocumentCloudService: Send + Sync {

frontend/rust-lib/flowy-document/src/manager.rs

@@ -1,5 +1,5 @@
+use crate::editor::DocumentRevisionCompactor;
 use crate::entities::EditParams;
-use crate::queue::DocumentRevisionCompactor;
 use crate::{editor::DocumentEditor, errors::FlowyError, DocumentCloudService};
 use bytes::Bytes;
 use dashmap::DashMap;
@@ -10,8 +10,8 @@ use flowy_revision::{
     RevisionCloudService, RevisionManager, RevisionPersistence, RevisionWebSocket, SQLiteRevisionSnapshotPersistence,
 };
 use flowy_sync::entities::{
+    document::{DocumentIdPB, DocumentOperationsPB},
     revision::{md5, RepeatedRevision, Revision},
-    text_block::{DocumentIdPB, DocumentOperationsPB},
     ws_data::ServerRevisionWSData,
 };
 use lib_infra::future::FutureResult;
@@ -24,14 +24,14 @@ pub trait DocumentUser: Send + Sync {
     fn db_pool(&self) -> Result<Arc<ConnectionPool>, FlowyError>;
 }
 
-pub struct DocumentEditorManager {
+pub struct DocumentManager {
     cloud_service: Arc<dyn DocumentCloudService>,
     rev_web_socket: Arc<dyn RevisionWebSocket>,
-    editor_map: Arc<TextEditorMap>,
+    editor_map: Arc<DocumentEditorMap>,
     user: Arc<dyn DocumentUser>,
 }
 
-impl DocumentEditorManager {
+impl DocumentManager {
     pub fn new(
         cloud_service: Arc<dyn DocumentCloudService>,
         document_user: Arc<dyn DocumentUser>,
@@ -40,7 +40,7 @@ impl DocumentEditorManager {
         Self {
             cloud_service,
             rev_web_socket,
-            editor_map: Arc::new(TextEditorMap::new()),
+            editor_map: Arc::new(DocumentEditorMap::new()),
             user: document_user,
         }
     }
@@ -59,7 +59,7 @@ impl DocumentEditorManager {
     }
 
     #[tracing::instrument(level = "trace", skip(self, editor_id), fields(editor_id), err)]
-    pub fn close_text_editor<T: AsRef<str>>(&self, editor_id: T) -> Result<(), FlowyError> {
+    pub fn close_document_editor<T: AsRef<str>>(&self, editor_id: T) -> Result<(), FlowyError> {
         let editor_id = editor_id.as_ref();
         tracing::Span::current().record("editor_id", &editor_id);
         self.editor_map.remove(editor_id);
@@ -116,19 +116,38 @@ impl DocumentEditorManager {
     }
 }
 
-impl DocumentEditorManager {
+impl DocumentManager {
+    /// Returns the `DocumentEditor`
+    /// Initializes the document editor if it's not initialized yet. Otherwise, returns the opened
+    /// editor.
+    ///
+    /// # Arguments
+    ///
+    /// * `doc_id`: the id of the document
+    ///
+    /// returns: Result<Arc<DocumentEditor>, FlowyError>
+    ///
     async fn get_document_editor(&self, doc_id: &str) -> FlowyResult<Arc<DocumentEditor>> {
         match self.editor_map.get(doc_id) {
             None => {
                 let db_pool = self.user.db_pool()?;
-                self.make_document_editor(doc_id, db_pool).await
+                self.init_document_editor(doc_id, db_pool).await
             }
             Some(editor) => Ok(editor),
         }
     }
 
+    /// Initializes a document editor with the doc_id
+    ///
+    /// # Arguments
+    ///
+    /// * `doc_id`: the id of the document
+    /// * `pool`: sqlite connection pool
+    ///
+    /// returns: Result<Arc<DocumentEditor>, FlowyError>
+    ///
     #[tracing::instrument(level = "trace", skip(self, pool), err)]
-    async fn make_document_editor(
+    async fn init_document_editor(
         &self,
         doc_id: &str,
         pool: Arc<ConnectionPool>,
@@ -202,11 +221,11 @@ impl RevisionCloudService for DocumentRevisionCloudService {
     }
 }
 
-pub struct TextEditorMap {
+pub struct DocumentEditorMap {
     inner: DashMap<String, Arc<DocumentEditor>>,
 }
 
-impl TextEditorMap {
+impl DocumentEditorMap {
     fn new() -> Self {
         Self { inner: DashMap::new() }
     }
@@ -231,7 +250,7 @@ impl TextEditorMap {
 }
 
 #[tracing::instrument(level = "trace", skip(web_socket, handlers))]
-fn listen_ws_state_changed(web_socket: Arc<dyn RevisionWebSocket>, handlers: Arc<TextEditorMap>) {
+fn listen_ws_state_changed(web_socket: Arc<dyn RevisionWebSocket>, handlers: Arc<DocumentEditorMap>) {
     tokio::spawn(async move {
         let mut notify = web_socket.subscribe_state_changed().await;
         while let Ok(state) = notify.recv().await {

frontend/rust-lib/flowy-document/src/queue.rs

@@ -1,17 +1,16 @@
 use crate::web_socket::EditorCommandReceiver;
 use crate::DocumentUser;
 use async_stream::stream;
-use bytes::Bytes;
-use flowy_error::{FlowyError, FlowyResult};
-use flowy_revision::{OperationsMD5, RevisionCompactor, RevisionManager, TextTransformOperations, TransformOperations};
-use flowy_sync::util::make_operations_from_revisions;
+use flowy_error::FlowyError;
+use flowy_revision::{OperationsMD5, RevisionManager, TextTransformOperations, TransformOperations};
+
 use flowy_sync::{
     client_document::{history::UndoResult, ClientDocument},
     entities::revision::{RevId, Revision},
     errors::CollaborateError,
 };
 use futures::stream::StreamExt;
-use lib_ot::core::{AttributeEntry, AttributeHashMap};
+use lib_ot::core::AttributeEntry;
 use lib_ot::{
     core::{Interval, OperationTransform},
     text_delta::TextOperations,
@@ -185,14 +184,6 @@ impl EditDocumentQueue {
     }
 }
 
-pub(crate) struct DocumentRevisionCompactor();
-impl RevisionCompactor for DocumentRevisionCompactor {
-    fn bytes_from_revisions(&self, revisions: Vec<Revision>) -> FlowyResult<Bytes> {
-        let operations = make_operations_from_revisions::<AttributeHashMap>(revisions)?;
-        Ok(operations.json_bytes())
-    }
-}
-
 pub(crate) type Ret<T> = oneshot::Sender<Result<T, CollaborateError>>;
 
 pub(crate) enum EditorCommand {

frontend/rust-lib/flowy-document/src/web_socket.rs

@@ -11,7 +11,6 @@ use flowy_sync::{
 };
 use lib_infra::future::{BoxResultFuture, FutureResult};
 use lib_ot::core::AttributeHashMap;
-
 use lib_ot::text_delta::TextOperations;
 use lib_ws::WSConnectState;
 use std::{sync::Arc, time::Duration};
@@ -33,11 +32,11 @@ pub(crate) async fn make_document_ws_manager(
     rev_web_socket: Arc<dyn RevisionWebSocket>,
 ) -> Arc<RevisionWebSocketManager> {
     let ws_data_provider = Arc::new(WSDataProvider::new(&doc_id, Arc::new(rev_manager.clone())));
-    let resolver = Arc::new(TextBlockConflictResolver { edit_cmd_tx });
+    let resolver = Arc::new(DocumentConflictResolver { edit_cmd_tx });
     let conflict_controller =
         RichTextConflictController::new(&user_id, resolver, Arc::new(ws_data_provider.clone()), rev_manager);
-    let ws_data_stream = Arc::new(TextBlockRevisionWSDataStream::new(conflict_controller));
-    let ws_data_sink = Arc::new(TextBlockWSDataSink(ws_data_provider));
+    let ws_data_stream = Arc::new(DocumentRevisionWSDataStream::new(conflict_controller));
+    let ws_data_sink = Arc::new(DocumentWSDataSink(ws_data_provider));
     let ping_duration = Duration::from_millis(TEXT_BLOCK_SYNC_INTERVAL_IN_MILLIS);
     let ws_manager = Arc::new(RevisionWebSocketManager::new(
         "Block",
@@ -65,11 +64,11 @@ fn listen_document_ws_state(_user_id: &str, _doc_id: &str, mut subscriber: broad
     });
 }
 
-pub(crate) struct TextBlockRevisionWSDataStream {
+pub(crate) struct DocumentRevisionWSDataStream {
     conflict_controller: Arc<RichTextConflictController>,
 }
 
-impl TextBlockRevisionWSDataStream {
+impl DocumentRevisionWSDataStream {
     #[allow(dead_code)]
     pub fn new(conflict_controller: RichTextConflictController) -> Self {
         Self {
@@ -78,7 +77,7 @@ impl TextBlockRevisionWSDataStream {
     }
 }
 
-impl RevisionWSDataStream for TextBlockRevisionWSDataStream {
+impl RevisionWSDataStream for DocumentRevisionWSDataStream {
     fn receive_push_revision(&self, bytes: Bytes) -> BoxResultFuture<(), FlowyError> {
         let resolver = self.conflict_controller.clone();
         Box::pin(async move { resolver.receive_bytes(bytes).await })
@@ -100,19 +99,19 @@ impl RevisionWSDataStream for TextBlockRevisionWSDataStream {
     }
 }
 
-pub(crate) struct TextBlockWSDataSink(pub(crate) Arc<WSDataProvider>);
-impl RevisionWebSocketSink for TextBlockWSDataSink {
+pub(crate) struct DocumentWSDataSink(pub(crate) Arc<WSDataProvider>);
+impl RevisionWebSocketSink for DocumentWSDataSink {
     fn next(&self) -> FutureResult<Option<ClientRevisionWSData>, FlowyError> {
         let sink_provider = self.0.clone();
         FutureResult::new(async move { sink_provider.next().await })
     }
 }
 
-struct TextBlockConflictResolver {
+struct DocumentConflictResolver {
     edit_cmd_tx: EditorCommandSender,
 }
 
-impl ConflictResolver<AttributeHashMap> for TextBlockConflictResolver {
+impl ConflictResolver<AttributeHashMap> for DocumentConflictResolver {
     fn compose_operations(&self, operations: TextOperations) -> BoxResultFuture<OperationsMD5, FlowyError> {
         let tx = self.edit_cmd_tx.clone();
         Box::pin(async move {

frontend/rust-lib/flowy-document/tests/document/script.rs

@@ -17,12 +17,12 @@ pub enum EditorScript {
     AssertJson(&'static str),
 }
 
-pub struct TextBlockEditorTest {
+pub struct DocumentEditorTest {
     pub sdk: FlowySDKTest,
     pub editor: Arc<DocumentEditor>,
 }
 
-impl TextBlockEditorTest {
+impl DocumentEditorTest {
     pub async fn new() -> Self {
         let sdk = FlowySDKTest::default();
         let _ = sdk.init_user().await;

frontend/rust-lib/flowy-document/tests/document/text_block_test.rs

@@ -14,7 +14,7 @@ async fn text_block_sync_current_rev_id_check() {
         AssertNextSyncRevId(None),
         AssertJson(r#"[{"insert":"123\n"}]"#),
     ];
-    TextBlockEditorTest::new().await.run_scripts(scripts).await;
+    DocumentEditorTest::new().await.run_scripts(scripts).await;
 }
 
 #[tokio::test]
@@ -28,7 +28,7 @@ async fn text_block_sync_state_check() {
         AssertRevisionState(3, RevisionState::Ack),
         AssertJson(r#"[{"insert":"123\n"}]"#),
     ];
-    TextBlockEditorTest::new().await.run_scripts(scripts).await;
+    DocumentEditorTest::new().await.run_scripts(scripts).await;
 }
 
 #[tokio::test]
@@ -40,7 +40,7 @@ async fn text_block_sync_insert_test() {
         AssertJson(r#"[{"insert":"123\n"}]"#),
         AssertNextSyncRevId(None),
     ];
-    TextBlockEditorTest::new().await.run_scripts(scripts).await;
+    DocumentEditorTest::new().await.run_scripts(scripts).await;
 }
 
 #[tokio::test]
@@ -52,7 +52,7 @@ async fn text_block_sync_insert_in_chinese() {
         InsertText("好", offset),
         AssertJson(r#"[{"insert":"你好\n"}]"#),
     ];
-    TextBlockEditorTest::new().await.run_scripts(scripts).await;
+    DocumentEditorTest::new().await.run_scripts(scripts).await;
 }
 
 #[tokio::test]
@@ -64,7 +64,7 @@ async fn text_block_sync_insert_with_emoji() {
         InsertText("☺️", offset),
         AssertJson(r#"[{"insert":"😁☺️\n"}]"#),
     ];
-    TextBlockEditorTest::new().await.run_scripts(scripts).await;
+    DocumentEditorTest::new().await.run_scripts(scripts).await;
 }
 
 #[tokio::test]
@@ -76,7 +76,7 @@ async fn text_block_sync_delete_in_english() {
         Delete(Interval::new(0, 2)),
         AssertJson(r#"[{"insert":"3\n"}]"#),
     ];
-    TextBlockEditorTest::new().await.run_scripts(scripts).await;
+    DocumentEditorTest::new().await.run_scripts(scripts).await;
 }
 
 #[tokio::test]
@@ -89,7 +89,7 @@ async fn text_block_sync_delete_in_chinese() {
         Delete(Interval::new(0, offset)),
         AssertJson(r#"[{"insert":"好\n"}]"#),
     ];
-    TextBlockEditorTest::new().await.run_scripts(scripts).await;
+    DocumentEditorTest::new().await.run_scripts(scripts).await;
 }
 
 #[tokio::test]
@@ -101,5 +101,5 @@ async fn text_block_sync_replace_test() {
         Replace(Interval::new(0, 3), "abc"),
         AssertJson(r#"[{"insert":"abc\n"}]"#),
     ];
-    TextBlockEditorTest::new().await.run_scripts(scripts).await;
+    DocumentEditorTest::new().await.run_scripts(scripts).await;
 }

frontend/rust-lib/flowy-folder/src/services/folder_editor.rs

@@ -2,7 +2,8 @@ use crate::manager::FolderId;
 use bytes::Bytes;
 use flowy_error::{FlowyError, FlowyResult};
 use flowy_revision::{
-    RevisionCloudService, RevisionCompactor, RevisionManager, RevisionObjectBuilder, RevisionWebSocket,
+    RevisionCloudService, RevisionCompress, RevisionManager, RevisionObjectDeserializer, RevisionObjectSerializer,
+    RevisionWebSocket,
 };
 use flowy_sync::util::make_operations_from_revisions;
 use flowy_sync::{
@@ -37,7 +38,7 @@ impl FolderEditor {
         let cloud = Arc::new(FolderRevisionCloudService {
             token: token.to_string(),
         });
-        let folder = Arc::new(RwLock::new(rev_manager.load::<FolderPadBuilder>(Some(cloud)).await?));
+        let folder = Arc::new(RwLock::new(rev_manager.load::<FolderRevisionSerde>(Some(cloud)).await?));
         let rev_manager = Arc::new(rev_manager);
 
         #[cfg(feature = "sync")]
@@ -100,16 +101,30 @@ impl FolderEditor {
     }
 }
 
-struct FolderPadBuilder();
-impl RevisionObjectBuilder for FolderPadBuilder {
+struct FolderRevisionSerde();
+impl RevisionObjectDeserializer for FolderRevisionSerde {
     type Output = FolderPad;
 
-    fn build_object(_object_id: &str, revisions: Vec<Revision>) -> FlowyResult<Self::Output> {
+    fn deserialize_revisions(_object_id: &str, revisions: Vec<Revision>) -> FlowyResult<Self::Output> {
         let pad = FolderPad::from_revisions(revisions)?;
         Ok(pad)
     }
 }
 
+impl RevisionObjectSerializer for FolderRevisionSerde {
+    fn serialize_revisions(revisions: Vec<Revision>) -> FlowyResult<Bytes> {
+        let operations = make_operations_from_revisions::<EmptyAttributes>(revisions)?;
+        Ok(operations.json_bytes())
+    }
+}
+
+pub struct FolderRevisionCompactor();
+impl RevisionCompress for FolderRevisionCompactor {
+    fn serialize_revisions(&self, revisions: Vec<Revision>) -> FlowyResult<Bytes> {
+        FolderRevisionSerde::serialize_revisions(revisions)
+    }
+}
+
 struct FolderRevisionCloudService {
     #[allow(dead_code)]
     token: String,
@@ -128,11 +143,3 @@ impl FolderEditor {
         self.rev_manager.clone()
     }
 }
-
-pub struct FolderRevisionCompactor();
-impl RevisionCompactor for FolderRevisionCompactor {
-    fn bytes_from_revisions(&self, revisions: Vec<Revision>) -> FlowyResult<Bytes> {
-        let operations = make_operations_from_revisions::<EmptyAttributes>(revisions)?;
-        Ok(operations.json_bytes())
-    }
-}

frontend/rust-lib/flowy-folder/src/services/view/controller.rs

@@ -17,7 +17,7 @@ use crate::{
 use bytes::Bytes;
 use flowy_database::kv::KV;
 use flowy_folder_data_model::revision::{gen_view_id, ViewRevision};
-use flowy_sync::entities::text_block::DocumentIdPB;
+use flowy_sync::entities::document::DocumentIdPB;
 use futures::{FutureExt, StreamExt};
 use std::{collections::HashSet, sync::Arc};
 

frontend/rust-lib/flowy-folder/tests/workspace/script.rs

@@ -18,7 +18,7 @@ use flowy_folder::{errors::ErrorCode, services::folder_editor::FolderEditor};
 
 use flowy_revision::disk::RevisionState;
 use flowy_revision::REVISION_WRITE_INTERVAL_IN_MILLIS;
-use flowy_sync::entities::text_block::DocumentPayloadPB;
+use flowy_sync::entities::document::DocumentPayloadPB;
 use flowy_test::{event_builder::*, FlowySDKTest};
 use std::{sync::Arc, time::Duration};
 use tokio::time::sleep;

frontend/rust-lib/flowy-grid/src/services/block_editor.rs

@@ -2,7 +2,9 @@ use crate::entities::RowPB;
 use bytes::Bytes;
 use flowy_error::{FlowyError, FlowyResult};
 use flowy_grid_data_model::revision::{CellRevision, GridBlockRevision, RowChangeset, RowRevision};
-use flowy_revision::{RevisionCloudService, RevisionCompactor, RevisionManager, RevisionObjectBuilder};
+use flowy_revision::{
+    RevisionCloudService, RevisionCompress, RevisionManager, RevisionObjectDeserializer, RevisionObjectSerializer,
+};
 use flowy_sync::client_grid::{GridBlockRevisionChangeset, GridBlockRevisionPad};
 use flowy_sync::entities::revision::Revision;
 use flowy_sync::util::make_operations_from_revisions;
@@ -30,7 +32,7 @@ impl GridBlockRevisionEditor {
         let cloud = Arc::new(GridBlockRevisionCloudService {
             token: token.to_owned(),
         });
-        let block_revision_pad = rev_manager.load::<GridBlockRevisionPadBuilder>(Some(cloud)).await?;
+        let block_revision_pad = rev_manager.load::<GridBlockRevisionSerde>(Some(cloud)).await?;
         let pad = Arc::new(RwLock::new(block_revision_pad));
         let rev_manager = Arc::new(rev_manager);
         let user_id = user_id.to_owned();
@@ -192,20 +194,25 @@ impl RevisionCloudService for GridBlockRevisionCloudService {
     }
 }
 
-struct GridBlockRevisionPadBuilder();
-impl RevisionObjectBuilder for GridBlockRevisionPadBuilder {
+struct GridBlockRevisionSerde();
+impl RevisionObjectDeserializer for GridBlockRevisionSerde {
     type Output = GridBlockRevisionPad;
-
-    fn build_object(object_id: &str, revisions: Vec<Revision>) -> FlowyResult<Self::Output> {
+    fn deserialize_revisions(object_id: &str, revisions: Vec<Revision>) -> FlowyResult<Self::Output> {
         let pad = GridBlockRevisionPad::from_revisions(object_id, revisions)?;
         Ok(pad)
     }
 }
 
-pub struct GridBlockRevisionCompactor();
-impl RevisionCompactor for GridBlockRevisionCompactor {
-    fn bytes_from_revisions(&self, revisions: Vec<Revision>) -> FlowyResult<Bytes> {
+impl RevisionObjectSerializer for GridBlockRevisionSerde {
+    fn serialize_revisions(revisions: Vec<Revision>) -> FlowyResult<Bytes> {
         let operations = make_operations_from_revisions::<EmptyAttributes>(revisions)?;
         Ok(operations.json_bytes())
     }
 }
+
+pub struct GridBlockRevisionCompactor();
+impl RevisionCompress for GridBlockRevisionCompactor {
+    fn serialize_revisions(&self, revisions: Vec<Revision>) -> FlowyResult<Bytes> {
+        GridBlockRevisionSerde::serialize_revisions(revisions)
+    }
+}

frontend/rust-lib/flowy-grid/src/services/grid_editor.rs

@@ -16,7 +16,9 @@ use crate::services::row::{make_grid_blocks, make_rows_from_row_revs, GridBlockS
 use bytes::Bytes;
 use flowy_error::{ErrorCode, FlowyError, FlowyResult};
 use flowy_grid_data_model::revision::*;
-use flowy_revision::{RevisionCloudService, RevisionCompactor, RevisionManager, RevisionObjectBuilder};
+use flowy_revision::{
+    RevisionCloudService, RevisionCompress, RevisionManager, RevisionObjectDeserializer, RevisionObjectSerializer,
+};
 use flowy_sync::client_grid::{GridRevisionChangeset, GridRevisionPad, JsonDeserializer};
 use flowy_sync::entities::revision::Revision;
 use flowy_sync::errors::{CollaborateError, CollaborateResult};
@@ -56,7 +58,7 @@ impl GridRevisionEditor {
     ) -> FlowyResult<Arc<Self>> {
         let token = user.token()?;
         let cloud = Arc::new(GridRevisionCloudService { token });
-        let grid_pad = rev_manager.load::<GridPadBuilder>(Some(cloud)).await?;
+        let grid_pad = rev_manager.load::<GridRevisionSerde>(Some(cloud)).await?;
         let rev_manager = Arc::new(rev_manager);
         let grid_pad = Arc::new(RwLock::new(grid_pad));
 
@@ -830,16 +832,21 @@ impl GridRevisionEditor {
     }
 }
 
-pub struct GridPadBuilder();
-impl RevisionObjectBuilder for GridPadBuilder {
+pub struct GridRevisionSerde();
+impl RevisionObjectDeserializer for GridRevisionSerde {
     type Output = GridRevisionPad;
 
-    fn build_object(_object_id: &str, revisions: Vec<Revision>) -> FlowyResult<Self::Output> {
+    fn deserialize_revisions(_object_id: &str, revisions: Vec<Revision>) -> FlowyResult<Self::Output> {
         let pad = GridRevisionPad::from_revisions(revisions)?;
         Ok(pad)
     }
 }
-
+impl RevisionObjectSerializer for GridRevisionSerde {
+    fn serialize_revisions(revisions: Vec<Revision>) -> FlowyResult<Bytes> {
+        let operations = make_operations_from_revisions::<EmptyAttributes>(revisions)?;
+        Ok(operations.json_bytes())
+    }
+}
 struct GridRevisionCloudService {
     #[allow(dead_code)]
     token: String,
@@ -853,10 +860,10 @@ impl RevisionCloudService for GridRevisionCloudService {
 }
 
 pub struct GridRevisionCompactor();
-impl RevisionCompactor for GridRevisionCompactor {
-    fn bytes_from_revisions(&self, revisions: Vec<Revision>) -> FlowyResult<Bytes> {
-        let operations = make_operations_from_revisions::<EmptyAttributes>(revisions)?;
-        Ok(operations.json_bytes())
+
+impl RevisionCompress for GridRevisionCompactor {
+    fn serialize_revisions(&self, revisions: Vec<Revision>) -> FlowyResult<Bytes> {
+        GridRevisionSerde::serialize_revisions(revisions)
     }
 }
 

frontend/rust-lib/flowy-grid/src/services/grid_view_editor.rs

@@ -11,15 +11,20 @@ use crate::services::group::{
     default_group_configuration, find_group_field, make_group_controller, GroupConfigurationReader,
     GroupConfigurationWriter, GroupController, MoveGroupRowContext,
 };
+use bytes::Bytes;
 use flowy_error::{FlowyError, FlowyResult};
 use flowy_grid_data_model::revision::{
     gen_grid_filter_id, FieldRevision, FieldTypeRevision, FilterConfigurationRevision, GroupConfigurationRevision,
     RowChangeset, RowRevision,
 };
-use flowy_revision::{RevisionCloudService, RevisionManager, RevisionObjectBuilder};
+use flowy_revision::{
+    RevisionCloudService, RevisionCompress, RevisionManager, RevisionObjectDeserializer, RevisionObjectSerializer,
+};
 use flowy_sync::client_grid::{GridViewRevisionChangeset, GridViewRevisionPad};
 use flowy_sync::entities::revision::Revision;
+use flowy_sync::util::make_operations_from_revisions;
 use lib_infra::future::{wrap_future, AFFuture, FutureResult};
+use lib_ot::core::EmptyAttributes;
 use std::future::Future;
 use std::sync::Arc;
 use tokio::sync::RwLock;
@@ -49,7 +54,7 @@ impl GridViewRevisionEditor {
         let cloud = Arc::new(GridViewRevisionCloudService {
             token: token.to_owned(),
         });
-        let view_revision_pad = rev_manager.load::<GridViewRevisionPadBuilder>(Some(cloud)).await?;
+        let view_revision_pad = rev_manager.load::<GridViewRevisionSerde>(Some(cloud)).await?;
         let pad = Arc::new(RwLock::new(view_revision_pad));
         let rev_manager = Arc::new(rev_manager);
         let group_controller = new_group_controller(
@@ -472,16 +477,30 @@ impl RevisionCloudService for GridViewRevisionCloudService {
     }
 }
 
-struct GridViewRevisionPadBuilder();
-impl RevisionObjectBuilder for GridViewRevisionPadBuilder {
+pub struct GridViewRevisionSerde();
+impl RevisionObjectDeserializer for GridViewRevisionSerde {
     type Output = GridViewRevisionPad;
 
-    fn build_object(object_id: &str, revisions: Vec<Revision>) -> FlowyResult<Self::Output> {
+    fn deserialize_revisions(object_id: &str, revisions: Vec<Revision>) -> FlowyResult<Self::Output> {
         let pad = GridViewRevisionPad::from_revisions(object_id, revisions)?;
         Ok(pad)
     }
 }
 
+impl RevisionObjectSerializer for GridViewRevisionSerde {
+    fn serialize_revisions(revisions: Vec<Revision>) -> FlowyResult<Bytes> {
+        let operations = make_operations_from_revisions::<EmptyAttributes>(revisions)?;
+        Ok(operations.json_bytes())
+    }
+}
+
+pub struct GridViewRevisionCompactor();
+impl RevisionCompress for GridViewRevisionCompactor {
+    fn serialize_revisions(&self, revisions: Vec<Revision>) -> FlowyResult<Bytes> {
+        GridViewRevisionSerde::serialize_revisions(revisions)
+    }
+}
+
 struct GroupConfigurationReaderImpl(Arc<RwLock<GridViewRevisionPad>>);
 
 impl GroupConfigurationReader for GroupConfigurationReaderImpl {

frontend/rust-lib/flowy-grid/src/services/grid_view_manager.rs

@@ -4,17 +4,14 @@ use crate::entities::{
 };
 use crate::manager::GridUser;
 use crate::services::grid_editor_task::GridServiceTaskScheduler;
-use crate::services::grid_view_editor::GridViewRevisionEditor;
-use bytes::Bytes;
+use crate::services::grid_view_editor::{GridViewRevisionCompactor, GridViewRevisionEditor};
+
 use dashmap::DashMap;
 use flowy_error::FlowyResult;
 use flowy_grid_data_model::revision::{FieldRevision, RowChangeset, RowRevision};
 use flowy_revision::disk::SQLiteGridViewRevisionPersistence;
-use flowy_revision::{RevisionCompactor, RevisionManager, RevisionPersistence, SQLiteRevisionSnapshotPersistence};
-use flowy_sync::entities::revision::Revision;
-use flowy_sync::util::make_operations_from_revisions;
+use flowy_revision::{RevisionManager, RevisionPersistence, SQLiteRevisionSnapshotPersistence};
 use lib_infra::future::AFFuture;
-use lib_ot::core::EmptyAttributes;
 use std::sync::Arc;
 
 type ViewId = String;
@@ -264,11 +261,3 @@ pub async fn make_grid_view_rev_manager(user: &Arc<dyn GridUser>, view_id: &str)
         snapshot_persistence,
     ))
 }
-
-pub struct GridViewRevisionCompactor();
-impl RevisionCompactor for GridViewRevisionCompactor {
-    fn bytes_from_revisions(&self, revisions: Vec<Revision>) -> FlowyResult<Bytes> {
-        let operations = make_operations_from_revisions::<EmptyAttributes>(revisions)?;
-        Ok(operations.json_bytes())
-    }
-}

frontend/rust-lib/flowy-grid/tests/grid/grid_editor.rs

@@ -6,7 +6,7 @@ use bytes::Bytes;
 use flowy_grid::entities::*;
 use flowy_grid::services::field::SelectOptionPB;
 use flowy_grid::services::field::*;
-use flowy_grid::services::grid_editor::{GridPadBuilder, GridRevisionEditor};
+use flowy_grid::services::grid_editor::{GridRevisionEditor, GridRevisionSerde};
 use flowy_grid::services::row::{CreateRowRevisionPayload, RowRevisionBuilder};
 use flowy_grid::services::setting::GridSettingChangesetBuilder;
 use flowy_grid_data_model::revision::*;

frontend/rust-lib/flowy-net/src/http_server/document.rs

@@ -4,7 +4,7 @@ use crate::{
 };
 use flowy_document::DocumentCloudService;
 use flowy_error::FlowyError;
-use flowy_sync::entities::text_block::{CreateDocumentParams, DocumentIdPB, DocumentPayloadPB, ResetDocumentParams};
+use flowy_sync::entities::document::{CreateDocumentParams, DocumentIdPB, DocumentPayloadPB, ResetDocumentParams};
 use http_flowy::response::FlowyResponse;
 use lazy_static::lazy_static;
 use lib_infra::future::FutureResult;

frontend/rust-lib/flowy-net/src/local_server/persistence.rs

@@ -1,6 +1,6 @@
 use flowy_sync::entities::revision::{RepeatedRevision, Revision};
 use flowy_sync::{
-    entities::{folder::FolderInfo, text_block::DocumentPayloadPB},
+    entities::{document::DocumentPayloadPB, folder::FolderInfo},
     errors::CollaborateError,
     server_document::*,
     server_folder::FolderCloudPersistence,
@@ -109,8 +109,8 @@ impl FolderCloudPersistence for LocalDocumentCloudPersistence {
     }
 }
 
-impl TextBlockCloudPersistence for LocalDocumentCloudPersistence {
-    fn read_text_block(&self, doc_id: &str) -> BoxResultFuture<DocumentPayloadPB, CollaborateError> {
+impl DocumentCloudPersistence for LocalDocumentCloudPersistence {
+    fn read_document(&self, doc_id: &str) -> BoxResultFuture<DocumentPayloadPB, CollaborateError> {
         let storage = self.storage.clone();
         let doc_id = doc_id.to_owned();
         Box::pin(async move {
@@ -122,7 +122,7 @@ impl TextBlockCloudPersistence for LocalDocumentCloudPersistence {
         })
     }
 
-    fn create_text_block(
+    fn create_document(
         &self,
         doc_id: &str,
         repeated_revision: RepeatedRevision,
@@ -135,7 +135,7 @@ impl TextBlockCloudPersistence for LocalDocumentCloudPersistence {
         })
     }
 
-    fn read_text_block_revisions(
+    fn read_document_revisions(
         &self,
         doc_id: &str,
         rev_ids: Option<Vec<i64>>,
@@ -148,7 +148,7 @@ impl TextBlockCloudPersistence for LocalDocumentCloudPersistence {
         })
     }
 
-    fn save_text_block_revisions(&self, repeated_revision: RepeatedRevision) -> BoxResultFuture<(), CollaborateError> {
+    fn save_document_revisions(&self, repeated_revision: RepeatedRevision) -> BoxResultFuture<(), CollaborateError> {
         let storage = self.storage.clone();
         Box::pin(async move {
             let _ = storage.set_revisions(repeated_revision).await?;
@@ -156,7 +156,7 @@ impl TextBlockCloudPersistence for LocalDocumentCloudPersistence {
         })
     }
 
-    fn reset_text_block(&self, doc_id: &str, revisions: RepeatedRevision) -> BoxResultFuture<(), CollaborateError> {
+    fn reset_document(&self, doc_id: &str, revisions: RepeatedRevision) -> BoxResultFuture<(), CollaborateError> {
         let storage = self.storage.clone();
         let doc_id = doc_id.to_owned();
         Box::pin(async move {

frontend/rust-lib/flowy-net/src/local_server/server.rs

@@ -6,7 +6,7 @@ use flowy_folder::event_map::FolderCouldServiceV1;
 use flowy_sync::{
     client_document::default::initial_document_str,
     entities::{
-        text_block::{CreateDocumentParams, DocumentIdPB, DocumentPayloadPB, ResetDocumentParams},
+        document::{CreateDocumentParams, DocumentIdPB, DocumentPayloadPB, ResetDocumentParams},
         ws_data::{ClientRevisionWSData, ClientRevisionWSDataType},
     },
     errors::CollaborateError,

frontend/rust-lib/flowy-revision/src/rev_manager.rs

@@ -9,21 +9,48 @@ use flowy_sync::{
 use lib_infra::future::FutureResult;
 use std::sync::Arc;
 
-pub type SyncObject = lib_ot::text_delta::TextOperations;
-
 pub trait RevisionCloudService: Send + Sync {
+    /// Read the object's revision from remote
+    /// Returns a list of revisions that used to build the object
+    /// # Arguments
+    ///
+    /// * `user_id`: the id of the user
+    /// * `object_id`: the id of the object
+    ///
     fn fetch_object(&self, user_id: &str, object_id: &str) -> FutureResult<Vec<Revision>, FlowyError>;
 }
 
-pub trait RevisionObjectBuilder: Send + Sync {
+pub trait RevisionObjectDeserializer: Send + Sync {
     type Output;
-    fn build_object(object_id: &str, revisions: Vec<Revision>) -> FlowyResult<Self::Output>;
+    /// Deserialize the list of revisions into an concrete object type.
+    ///
+    /// # Arguments
+    ///
+    /// * `object_id`: the id of the object
+    /// * `revisions`: a list of revisions that represent the object
+    ///
+    fn deserialize_revisions(object_id: &str, revisions: Vec<Revision>) -> FlowyResult<Self::Output>;
+}
+
+pub trait RevisionObjectSerializer: Send + Sync {
+    /// Serialize the list of revisions to `Bytes`
+    ///
+    /// * `revisions`: a list of revisions will be serialized to `Bytes`
+    ///
+    fn serialize_revisions(revisions: Vec<Revision>) -> FlowyResult<Bytes>;
 }
 
-pub trait RevisionCompactor: Send + Sync {
-    fn compact(&self, user_id: &str, object_id: &str, mut revisions: Vec<Revision>) -> FlowyResult<Revision> {
+/// `RevisionCompress` is used to compress multiple revisions into one revision
+///
+pub trait RevisionCompress: Send + Sync {
+    fn compress_revisions(
+        &self,
+        user_id: &str,
+        object_id: &str,
+        mut revisions: Vec<Revision>,
+    ) -> FlowyResult<Revision> {
         if revisions.is_empty() {
-            return Err(FlowyError::internal().context("Can't compact the empty folder's revisions"));
+            return Err(FlowyError::internal().context("Can't compact the empty revisions"));
         }
 
         if revisions.len() == 1 {
@@ -35,11 +62,11 @@ pub trait RevisionCompactor: Send + Sync {
 
         let (base_rev_id, rev_id) = first_revision.pair_rev_id();
         let md5 = last_revision.md5.clone();
-        let bytes = self.bytes_from_revisions(revisions)?;
+        let bytes = self.serialize_revisions(revisions)?;
         Ok(Revision::new(object_id, base_rev_id, rev_id, bytes, user_id, md5))
     }
 
-    fn bytes_from_revisions(&self, revisions: Vec<Revision>) -> FlowyResult<Bytes>;
+    fn serialize_revisions(&self, revisions: Vec<Revision>) -> FlowyResult<Bytes>;
 }
 
 pub struct RevisionManager {
@@ -49,7 +76,7 @@ pub struct RevisionManager {
     rev_persistence: Arc<RevisionPersistence>,
     #[allow(dead_code)]
     rev_snapshot: Arc<RevisionSnapshotManager>,
-    rev_compactor: Arc<dyn RevisionCompactor>,
+    rev_compress: Arc<dyn RevisionCompress>,
     #[cfg(feature = "flowy_unit_test")]
     rev_ack_notifier: tokio::sync::broadcast::Sender<i64>,
 }
@@ -64,13 +91,11 @@ impl RevisionManager {
     ) -> Self
     where
         SP: 'static + RevisionSnapshotDiskCache,
-        C: 'static + RevisionCompactor,
+        C: 'static + RevisionCompress,
     {
         let rev_id_counter = RevIdCounter::new(0);
         let rev_compactor = Arc::new(rev_compactor);
-
         let rev_persistence = Arc::new(rev_persistence);
-
         let rev_snapshot = Arc::new(RevisionSnapshotManager::new(user_id, object_id, snapshot_persistence));
         #[cfg(feature = "flowy_unit_test")]
         let (revision_ack_notifier, _) = tokio::sync::broadcast::channel(1);
@@ -81,7 +106,7 @@ impl RevisionManager {
             rev_id_counter,
             rev_persistence,
             rev_snapshot,
-            rev_compactor,
+            rev_compress: rev_compactor,
             #[cfg(feature = "flowy_unit_test")]
             rev_ack_notifier: revision_ack_notifier,
         }
@@ -90,7 +115,7 @@ impl RevisionManager {
     #[tracing::instrument(level = "debug", skip_all, fields(object_id) err)]
     pub async fn load<B>(&mut self, cloud: Option<Arc<dyn RevisionCloudService>>) -> FlowyResult<B::Output>
     where
-        B: RevisionObjectBuilder,
+        B: RevisionObjectDeserializer,
     {
         let (revisions, rev_id) = RevisionLoader {
             object_id: self.object_id.clone(),
@@ -102,7 +127,7 @@ impl RevisionManager {
         .await?;
         self.rev_id_counter.set(rev_id);
         tracing::Span::current().record("object_id", &self.object_id.as_str());
-        B::build_object(&self.object_id, revisions)
+        B::deserialize_revisions(&self.object_id, revisions)
     }
 
     #[tracing::instrument(level = "debug", skip(self, revisions), err)]
@@ -116,7 +141,7 @@ impl RevisionManager {
     #[tracing::instrument(level = "debug", skip(self, revision), err)]
     pub async fn add_remote_revision(&self, revision: &Revision) -> Result<(), FlowyError> {
         if revision.bytes.is_empty() {
-            return Err(FlowyError::internal().context("Delta data should be empty"));
+            return Err(FlowyError::internal().context("Remote revisions is empty"));
         }
 
         let _ = self.rev_persistence.add_ack_revision(revision).await?;
@@ -128,11 +153,11 @@ impl RevisionManager {
     #[tracing::instrument(level = "debug", skip_all, err)]
     pub async fn add_local_revision(&self, revision: &Revision) -> Result<(), FlowyError> {
         if revision.bytes.is_empty() {
-            return Err(FlowyError::internal().context("Delta data should be empty"));
+            return Err(FlowyError::internal().context("Local revisions is empty"));
         }
         let rev_id = self
             .rev_persistence
-            .add_sync_revision(revision, &self.rev_compactor)
+            .add_sync_revision(revision, &self.rev_compress)
             .await?;
         // self.rev_history.add_revision(revision).await;
         self.rev_id_counter.set(rev_id);

frontend/rust-lib/flowy-revision/src/rev_persistence.rs

@@ -4,7 +4,7 @@ use crate::cache::{
 };
 use crate::disk::{RevisionRecord, RevisionState, SQLiteGridBlockRevisionPersistence};
 use crate::memory::RevisionMemoryCache;
-use crate::RevisionCompactor;
+use crate::RevisionCompress;
 use flowy_database::ConnectionPool;
 use flowy_error::{internal_error, FlowyError, FlowyResult};
 use flowy_sync::entities::revision::{Revision, RevisionRange};
@@ -71,7 +71,7 @@ impl RevisionPersistence {
     pub(crate) async fn add_sync_revision<'a>(
         &'a self,
         revision: &'a Revision,
-        compactor: &Arc<dyn RevisionCompactor + 'a>,
+        rev_compress: &Arc<dyn RevisionCompress + 'a>,
     ) -> FlowyResult<i64> {
         let mut sync_seq_write_guard = self.sync_seq.write().await;
         let result = sync_seq_write_guard.compact();
@@ -93,7 +93,7 @@ impl RevisionPersistence {
                 revisions.push(revision.clone());
 
                 // compact multiple revisions into one
-                let compact_revision = compactor.compact(&self.user_id, &self.object_id, revisions)?;
+                let compact_revision = rev_compress.compress_revisions(&self.user_id, &self.object_id, revisions)?;
                 let rev_id = compact_revision.rev_id;
                 tracing::Span::current().record("rev_id", &rev_id);
 

frontend/rust-lib/flowy-sdk/src/deps_resolve/document_deps.rs

@@ -2,7 +2,7 @@ use bytes::Bytes;
 use flowy_database::ConnectionPool;
 use flowy_document::{
     errors::{internal_error, FlowyError},
-    DocumentCloudService, DocumentEditorManager, DocumentUser,
+    DocumentCloudService, DocumentManager, DocumentUser,
 };
 use flowy_net::ClientServerConfiguration;
 use flowy_net::{
@@ -23,7 +23,7 @@ impl DocumentDepsResolver {
         ws_conn: Arc<FlowyWebSocketConnect>,
         user_session: Arc<UserSession>,
         server_config: &ClientServerConfiguration,
-    ) -> Arc<DocumentEditorManager> {
+    ) -> Arc<DocumentManager> {
         let user = Arc::new(BlockUserImpl(user_session));
         let rev_web_socket = Arc::new(DocumentRevisionWebSocket(ws_conn.clone()));
         let cloud_service: Arc<dyn DocumentCloudService> = match local_server {
@@ -31,7 +31,7 @@ impl DocumentDepsResolver {
             Some(local_server) => local_server,
         };
 
-        let manager = Arc::new(DocumentEditorManager::new(cloud_service, user, rev_web_socket));
+        let manager = Arc::new(DocumentManager::new(cloud_service, user, rev_web_socket));
         let receiver = Arc::new(DocumentWSMessageReceiverImpl(manager.clone()));
         ws_conn.add_ws_message_receiver(receiver).unwrap();
 
@@ -90,7 +90,7 @@ impl RevisionWebSocket for DocumentRevisionWebSocket {
     }
 }
 
-struct DocumentWSMessageReceiverImpl(Arc<DocumentEditorManager>);
+struct DocumentWSMessageReceiverImpl(Arc<DocumentManager>);
 impl WSMessageReceiver for DocumentWSMessageReceiverImpl {
     fn source(&self) -> WSChannel {
         WSChannel::Document

frontend/rust-lib/flowy-sdk/src/deps_resolve/folder_deps.rs

@@ -1,6 +1,6 @@
 use bytes::Bytes;
 use flowy_database::ConnectionPool;
-use flowy_document::DocumentEditorManager;
+use flowy_document::DocumentManager;
 use flowy_folder::entities::{ViewDataTypePB, ViewLayoutTypePB};
 use flowy_folder::manager::{ViewDataProcessor, ViewDataProcessorMap};
 use flowy_folder::{
@@ -35,7 +35,7 @@ impl FolderDepsResolver {
         user_session: Arc<UserSession>,
         server_config: &ClientServerConfiguration,
         ws_conn: &Arc<FlowyWebSocketConnect>,
-        text_block_manager: &Arc<DocumentEditorManager>,
+        text_block_manager: &Arc<DocumentManager>,
         grid_manager: &Arc<GridManager>,
     ) -> Arc<FolderManager> {
         let user: Arc<dyn WorkspaceUser> = Arc::new(WorkspaceUserImpl(user_session.clone()));
@@ -64,7 +64,7 @@ impl FolderDepsResolver {
 }
 
 fn make_view_data_processor(
-    text_block_manager: Arc<DocumentEditorManager>,
+    text_block_manager: Arc<DocumentManager>,
     grid_manager: Arc<GridManager>,
 ) -> ViewDataProcessorMap {
     let mut map: HashMap<ViewDataTypePB, Arc<dyn ViewDataProcessor + Send + Sync>> = HashMap::new();
@@ -136,7 +136,7 @@ impl WSMessageReceiver for FolderWSMessageReceiverImpl {
     }
 }
 
-struct DocumentViewDataProcessor(Arc<DocumentEditorManager>);
+struct DocumentViewDataProcessor(Arc<DocumentManager>);
 impl ViewDataProcessor for DocumentViewDataProcessor {
     fn initialize(&self) -> FutureResult<(), FlowyError> {
         let manager = self.0.clone();
@@ -165,7 +165,7 @@ impl ViewDataProcessor for DocumentViewDataProcessor {
         let manager = self.0.clone();
         let view_id = view_id.to_string();
         FutureResult::new(async move {
-            let _ = manager.close_text_editor(view_id)?;
+            let _ = manager.close_document_editor(view_id)?;
             Ok(())
         })
     }

frontend/rust-lib/flowy-sdk/src/lib.rs

@@ -3,7 +3,7 @@ pub mod module;
 pub use flowy_net::get_client_server_configuration;
 
 use crate::deps_resolve::*;
-use flowy_document::DocumentEditorManager;
+use flowy_document::DocumentManager;
 use flowy_folder::{errors::FlowyError, manager::FolderManager};
 use flowy_grid::manager::GridManager;
 use flowy_net::ClientServerConfiguration;
@@ -89,7 +89,7 @@ pub struct FlowySDK {
     #[allow(dead_code)]
     config: FlowySDKConfig,
     pub user_session: Arc<UserSession>,
-    pub text_block_manager: Arc<DocumentEditorManager>,
+    pub text_block_manager: Arc<DocumentManager>,
     pub folder_manager: Arc<FolderManager>,
     pub grid_manager: Arc<GridManager>,
     pub dispatcher: Arc<EventDispatcher>,

frontend/rust-lib/flowy-sdk/src/module.rs

@@ -1,4 +1,4 @@
-use flowy_document::DocumentEditorManager;
+use flowy_document::DocumentManager;
 use flowy_folder::manager::FolderManager;
 use flowy_grid::manager::GridManager;
 use flowy_net::ws::connection::FlowyWebSocketConnect;
@@ -11,7 +11,7 @@ pub fn mk_modules(
     folder_manager: &Arc<FolderManager>,
     grid_manager: &Arc<GridManager>,
     user_session: &Arc<UserSession>,
-    text_block_manager: &Arc<DocumentEditorManager>,
+    text_block_manager: &Arc<DocumentManager>,
 ) -> Vec<Module> {
     let user_module = mk_user_module(user_session.clone());
     let folder_module = mk_folder_module(folder_manager.clone());
@@ -43,6 +43,6 @@ fn mk_grid_module(grid_manager: Arc<GridManager>) -> Module {
     flowy_grid::event_map::create(grid_manager)
 }
 
-fn mk_text_block_module(text_block_manager: Arc<DocumentEditorManager>) -> Module {
+fn mk_text_block_module(text_block_manager: Arc<DocumentManager>) -> Module {
     flowy_document::event_map::create(text_block_manager)
 }

shared-lib/flowy-sync/src/entities/text_block.rs → shared-lib/flowy-sync/src/entities/document.rs

@@ -29,13 +29,6 @@ pub struct DocumentPayloadPB {
     pub base_rev_id: i64,
 }
 
-impl DocumentPayloadPB {
-    pub fn delta(&self) -> Result<TextOperations, OTError> {
-        let delta = TextOperations::from_bytes(&self.content)?;
-        Ok(delta)
-    }
-}
-
 impl std::convert::TryFrom<Revision> for DocumentPayloadPB {
     type Error = CollaborateError;
 

shared-lib/flowy-sync/src/entities/mod.rs

@@ -1,5 +1,5 @@
+pub mod document;
 pub mod folder;
 pub mod parser;
 pub mod revision;
-pub mod text_block;
 pub mod ws_data;

shared-lib/flowy-sync/src/server_document/document_manager.rs

@@ -1,6 +1,6 @@
 use crate::entities::revision::{RepeatedRevision, Revision};
 use crate::{
-    entities::{text_block::DocumentPayloadPB, ws_data::ServerRevisionWSDataBuilder},
+    entities::{document::DocumentPayloadPB, ws_data::ServerRevisionWSDataBuilder},
     errors::{internal_error, CollaborateError, CollaborateResult},
     protobuf::ClientRevisionWSData,
     server_document::document_pad::ServerDocument,
@@ -19,41 +19,41 @@ use tokio::{
     task::spawn_blocking,
 };
 
-pub trait TextBlockCloudPersistence: Send + Sync + Debug {
-    fn read_text_block(&self, doc_id: &str) -> BoxResultFuture<DocumentPayloadPB, CollaborateError>;
+pub trait DocumentCloudPersistence: Send + Sync + Debug {
+    fn read_document(&self, doc_id: &str) -> BoxResultFuture<DocumentPayloadPB, CollaborateError>;
 
-    fn create_text_block(
+    fn create_document(
         &self,
         doc_id: &str,
         repeated_revision: RepeatedRevision,
     ) -> BoxResultFuture<Option<DocumentPayloadPB>, CollaborateError>;
 
-    fn read_text_block_revisions(
+    fn read_document_revisions(
         &self,
         doc_id: &str,
         rev_ids: Option<Vec<i64>>,
     ) -> BoxResultFuture<Vec<Revision>, CollaborateError>;
 
-    fn save_text_block_revisions(&self, repeated_revision: RepeatedRevision) -> BoxResultFuture<(), CollaborateError>;
+    fn save_document_revisions(&self, repeated_revision: RepeatedRevision) -> BoxResultFuture<(), CollaborateError>;
 
-    fn reset_text_block(
+    fn reset_document(
         &self,
         doc_id: &str,
         repeated_revision: RepeatedRevision,
     ) -> BoxResultFuture<(), CollaborateError>;
 }
 
-impl RevisionSyncPersistence for Arc<dyn TextBlockCloudPersistence> {
+impl RevisionSyncPersistence for Arc<dyn DocumentCloudPersistence> {
     fn read_revisions(
         &self,
         object_id: &str,
         rev_ids: Option<Vec<i64>>,
     ) -> BoxResultFuture<Vec<Revision>, CollaborateError> {
-        (**self).read_text_block_revisions(object_id, rev_ids)
+        (**self).read_document_revisions(object_id, rev_ids)
     }
 
     fn save_revisions(&self, repeated_revision: RepeatedRevision) -> BoxResultFuture<(), CollaborateError> {
-        (**self).save_text_block_revisions(repeated_revision)
+        (**self).save_document_revisions(repeated_revision)
     }
 
     fn reset_object(
@@ -61,17 +61,17 @@ impl RevisionSyncPersistence for Arc<dyn TextBlockCloudPersistence> {
         object_id: &str,
         repeated_revision: RepeatedRevision,
     ) -> BoxResultFuture<(), CollaborateError> {
-        (**self).reset_text_block(object_id, repeated_revision)
+        (**self).reset_document(object_id, repeated_revision)
     }
 }
 
 pub struct ServerDocumentManager {
     document_handlers: Arc<RwLock<HashMap<String, Arc<OpenDocumentHandler>>>>,
-    persistence: Arc<dyn TextBlockCloudPersistence>,
+    persistence: Arc<dyn DocumentCloudPersistence>,
 }
 
 impl ServerDocumentManager {
-    pub fn new(persistence: Arc<dyn TextBlockCloudPersistence>) -> Self {
+    pub fn new(persistence: Arc<dyn DocumentCloudPersistence>) -> Self {
         Self {
             document_handlers: Arc::new(RwLock::new(HashMap::new())),
             persistence,
@@ -154,7 +154,7 @@ impl ServerDocumentManager {
         }
 
         let mut write_guard = self.document_handlers.write().await;
-        match self.persistence.read_text_block(doc_id).await {
+        match self.persistence.read_document(doc_id).await {
             Ok(doc) => {
                 let handler = self.create_document_handler(doc).await.map_err(internal_error).unwrap();
                 write_guard.insert(doc_id.to_owned(), handler.clone());
@@ -170,7 +170,7 @@ impl ServerDocumentManager {
         doc_id: &str,
         repeated_revision: RepeatedRevision,
     ) -> Result<Arc<OpenDocumentHandler>, CollaborateError> {
-        match self.persistence.create_text_block(doc_id, repeated_revision).await? {
+        match self.persistence.create_document(doc_id, repeated_revision).await? {
             None => Err(CollaborateError::internal().context("Create document info from revisions failed")),
             Some(doc) => {
                 let handler = self.create_document_handler(doc).await?;
@@ -211,7 +211,7 @@ struct OpenDocumentHandler {
 }
 
 impl OpenDocumentHandler {
-    fn new(doc: DocumentPayloadPB, persistence: Arc<dyn TextBlockCloudPersistence>) -> Result<Self, CollaborateError> {
+    fn new(doc: DocumentPayloadPB, persistence: Arc<dyn DocumentCloudPersistence>) -> Result<Self, CollaborateError> {
         let doc_id = doc.doc_id.clone();
         let (sender, receiver) = mpsc::channel(1000);
         let users = DashMap::new();

shared-lib/flowy-sync/src/util.rs

@@ -1,9 +1,9 @@
 use crate::server_folder::FolderOperations;
 use crate::{
     entities::{
+        document::DocumentPayloadPB,
         folder::FolderInfo,
         revision::{RepeatedRevision, Revision},
-        text_block::DocumentPayloadPB,
     },
     errors::{CollaborateError, CollaborateResult},
 };