Refactor/rename crate (#1275)

frontend/rust-lib/flowy-folder/Cargo.toml

@@ -12,7 +12,7 @@ flowy-derive = { path = "../../../shared-lib/flowy-derive" }
 lib-ot = { path = "../../../shared-lib/lib-ot" }
 lib-infra = { path = "../../../shared-lib/lib-infra" }
 
-flowy-text-block = { path = "../flowy-text-block" }
+flowy-document = { path = "../flowy-document" }
 flowy-database = { path = "../flowy-database" }
 flowy-error = { path = "../flowy-error", features = ["db", "http_server"]}
 dart-notify = { path = "../dart-notify" }

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

@@ -14,7 +14,7 @@ use crate::{
 use bytes::Bytes;
 use flowy_error::FlowyError;
 use flowy_folder_data_model::user_default;
-use flowy_revision::disk::SQLiteTextBlockRevisionPersistence;
+use flowy_revision::disk::SQLiteDocumentRevisionPersistence;
 use flowy_revision::{RevisionManager, RevisionPersistence, RevisionWebSocket, SQLiteRevisionSnapshotPersistence};
 use flowy_sync::client_document::default::{initial_document_str, initial_read_me};
 use flowy_sync::{client_folder::FolderPad, entities::ws_data::ServerRevisionWSData};
@@ -164,7 +164,7 @@ impl FolderManager {
 
         let pool = self.persistence.db_pool()?;
         let object_id = folder_id.as_ref();
-        let disk_cache = SQLiteTextBlockRevisionPersistence::new(user_id, pool.clone());
+        let disk_cache = SQLiteDocumentRevisionPersistence::new(user_id, pool.clone());
         let rev_persistence = RevisionPersistence::new(user_id, object_id, disk_cache);
         let rev_compactor = FolderRevisionCompactor();
         // let history_persistence = SQLiteRevisionHistoryPersistence::new(object_id, pool.clone());

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/persistence/migration.rs

@@ -3,14 +3,16 @@ use crate::{
     event_map::WorkspaceDatabase,
     services::persistence::{AppTableSql, TrashTableSql, ViewTableSql, WorkspaceTableSql},
 };
+use bytes::Bytes;
 use flowy_database::kv::KV;
 use flowy_error::{FlowyError, FlowyResult};
 use flowy_folder_data_model::revision::{AppRevision, FolderRevision, ViewRevision, WorkspaceRevision};
-use flowy_revision::disk::SQLiteTextBlockRevisionPersistence;
+use flowy_revision::disk::SQLiteDocumentRevisionPersistence;
 use flowy_revision::reset::{RevisionResettable, RevisionStructReset};
 use flowy_sync::client_folder::make_folder_rev_json_str;
 use flowy_sync::entities::revision::Revision;
 use flowy_sync::{client_folder::FolderPad, entities::revision::md5};
+use lib_ot::core::DeltaBuilder;
 use std::sync::Arc;
 
 const V1_MIGRATION: &str = "FOLDER_V1_MIGRATION";
@@ -110,7 +112,7 @@ impl FolderMigration {
         };
 
         let pool = self.database.db_pool()?;
-        let disk_cache = SQLiteTextBlockRevisionPersistence::new(&self.user_id, pool);
+        let disk_cache = SQLiteDocumentRevisionPersistence::new(&self.user_id, pool);
         let reset = RevisionStructReset::new(&self.user_id, object, Arc::new(disk_cache));
         reset.run().await
     }
@@ -129,10 +131,11 @@ impl RevisionResettable for FolderRevisionResettable {
         &self.folder_id
     }
 
-    fn target_reset_rev_str(&self, revisions: Vec<Revision>) -> FlowyResult<String> {
+    fn reset_data(&self, revisions: Vec<Revision>) -> FlowyResult<Bytes> {
         let pad = FolderPad::from_revisions(revisions)?;
         let json = pad.to_json()?;
-        Ok(json)
+        let bytes = DeltaBuilder::new().insert(&json).build().json_bytes();
+        Ok(bytes)
     }
 
     fn default_target_rev_str(&self) -> FlowyResult<String> {

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::TextBlockIdPB;
+use flowy_sync::entities::document::DocumentIdPB;
 use futures::{FutureExt, StreamExt};
 use std::{collections::HashSet, sync::Arc};
 
@@ -193,7 +193,7 @@ impl ViewController {
     }
 
     #[tracing::instrument(level = "debug", skip(self,params), fields(doc_id = %params.value), err)]
-    pub(crate) async fn move_view_to_trash(&self, params: TextBlockIdPB) -> Result<(), FlowyError> {
+    pub(crate) async fn move_view_to_trash(&self, params: DocumentIdPB) -> Result<(), FlowyError> {
         let view_id = params.value;
         if let Some(latest_view_id) = KV::get_str(LATEST_VIEW_ID) {
             if latest_view_id == view_id {

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

@@ -1,7 +1,10 @@
 use crate::services::FOLDER_SYNC_INTERVAL_IN_MILLIS;
 use bytes::Bytes;
-use flowy_error::FlowyError;
+use flowy_error::{FlowyError, FlowyResult};
 use flowy_revision::*;
+use flowy_sync::entities::revision::Revision;
+use flowy_sync::server_folder::FolderOperations;
+use flowy_sync::util::make_operations_from_revisions;
 use flowy_sync::{
     client_folder::FolderPad,
     entities::{
@@ -10,10 +13,32 @@ use flowy_sync::{
     },
 };
 use lib_infra::future::{BoxResultFuture, FutureResult};
-use lib_ot::core::{Delta, EmptyAttributes, OperationTransform};
+use lib_ot::core::OperationTransform;
 use parking_lot::RwLock;
 use std::{sync::Arc, time::Duration};
 
+#[derive(Clone)]
+pub struct FolderResolveOperations(pub FolderOperations);
+impl OperationsDeserializer<FolderResolveOperations> for FolderResolveOperations {
+    fn deserialize_revisions(revisions: Vec<Revision>) -> FlowyResult<FolderResolveOperations> {
+        Ok(FolderResolveOperations(make_operations_from_revisions(revisions)?))
+    }
+}
+
+impl OperationsSerializer for FolderResolveOperations {
+    fn serialize_operations(&self) -> Bytes {
+        self.0.json_bytes()
+    }
+}
+
+impl FolderResolveOperations {
+    pub fn into_inner(self) -> FolderOperations {
+        self.0
+    }
+}
+
+pub type FolderConflictController = ConflictController<FolderResolveOperations>;
+
 #[allow(dead_code)]
 pub(crate) async fn make_folder_ws_manager(
     user_id: &str,
@@ -25,7 +50,7 @@ pub(crate) async fn make_folder_ws_manager(
     let ws_data_provider = Arc::new(WSDataProvider::new(folder_id, Arc::new(rev_manager.clone())));
     let resolver = Arc::new(FolderConflictResolver { folder_pad });
     let conflict_controller =
-        ConflictController::<EmptyAttributes>::new(user_id, resolver, Arc::new(ws_data_provider.clone()), rev_manager);
+        FolderConflictController::new(user_id, resolver, Arc::new(ws_data_provider.clone()), rev_manager);
     let ws_data_stream = Arc::new(FolderRevisionWSDataStream::new(conflict_controller));
     let ws_data_sink = Arc::new(FolderWSDataSink(ws_data_provider));
     let ping_duration = Duration::from_millis(FOLDER_SYNC_INTERVAL_IN_MILLIS);
@@ -51,52 +76,57 @@ struct FolderConflictResolver {
     folder_pad: Arc<RwLock<FolderPad>>,
 }
 
-impl ConflictResolver<EmptyAttributes> for FolderConflictResolver {
-    fn compose_delta(&self, delta: Delta) -> BoxResultFuture<OperationsMD5, FlowyError> {
+impl ConflictResolver<FolderResolveOperations> for FolderConflictResolver {
+    fn compose_operations(&self, operations: FolderResolveOperations) -> BoxResultFuture<OperationsMD5, FlowyError> {
+        let operations = operations.into_inner();
         let folder_pad = self.folder_pad.clone();
         Box::pin(async move {
-            let md5 = folder_pad.write().compose_remote_operations(delta)?;
+            let md5 = folder_pad.write().compose_remote_operations(operations)?;
             Ok(md5)
         })
     }
 
-    fn transform_delta(&self, delta: Delta) -> BoxResultFuture<TransformDeltas<EmptyAttributes>, FlowyError> {
+    fn transform_operations(
+        &self,
+        operations: FolderResolveOperations,
+    ) -> BoxResultFuture<TransformOperations<FolderResolveOperations>, FlowyError> {
         let folder_pad = self.folder_pad.clone();
+        let operations = operations.into_inner();
         Box::pin(async move {
             let read_guard = folder_pad.read();
-            let mut server_prime: Option<Delta> = None;
-            let client_prime: Delta;
+            let mut server_operations: Option<FolderResolveOperations> = None;
+            let client_operations: FolderResolveOperations;
             if read_guard.is_empty() {
                 // Do nothing
-                client_prime = delta;
+                client_operations = FolderResolveOperations(operations);
             } else {
-                let (s_prime, c_prime) = read_guard.get_operations().transform(&delta)?;
-                client_prime = c_prime;
-                server_prime = Some(s_prime);
+                let (s_prime, c_prime) = read_guard.get_operations().transform(&operations)?;
+                client_operations = FolderResolveOperations(c_prime);
+                server_operations = Some(FolderResolveOperations(s_prime));
             }
             drop(read_guard);
-            Ok(TransformDeltas {
-                client_prime,
-                server_prime,
+            Ok(TransformOperations {
+                client_operations,
+                server_operations,
             })
         })
     }
 
-    fn reset_delta(&self, delta: Delta) -> BoxResultFuture<OperationsMD5, FlowyError> {
+    fn reset_operations(&self, operations: FolderResolveOperations) -> BoxResultFuture<OperationsMD5, FlowyError> {
         let folder_pad = self.folder_pad.clone();
         Box::pin(async move {
-            let md5 = folder_pad.write().reset_folder(delta)?;
+            let md5 = folder_pad.write().reset_folder(operations.into_inner())?;
             Ok(md5)
         })
     }
 }
 
 struct FolderRevisionWSDataStream {
-    conflict_controller: Arc<PlainTextConflictController>,
+    conflict_controller: Arc<FolderConflictController>,
 }
 
 impl FolderRevisionWSDataStream {
-    pub fn new(conflict_controller: PlainTextConflictController) -> Self {
+    pub fn new(conflict_controller: FolderConflictController) -> Self {
         Self {
             conflict_controller: Arc::new(conflict_controller),
         }

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::DocumentPB;
+use flowy_sync::entities::document::DocumentPayloadPB;
 use flowy_test::{event_builder::*, FlowySDKTest};
 use std::{sync::Arc, time::Duration};
 use tokio::time::sleep;
@@ -412,14 +412,14 @@ pub async fn delete_view(sdk: &FlowySDKTest, view_ids: Vec<String>) {
 }
 
 #[allow(dead_code)]
-pub async fn set_latest_view(sdk: &FlowySDKTest, view_id: &str) -> DocumentPB {
+pub async fn set_latest_view(sdk: &FlowySDKTest, view_id: &str) -> DocumentPayloadPB {
     let view_id: ViewIdPB = view_id.into();
     FolderEventBuilder::new(sdk.clone())
         .event(SetLatestView)
         .payload(view_id)
         .async_send()
         .await
-        .parse::<DocumentPB>()
+        .parse::<DocumentPayloadPB>()
 }
 
 pub async fn read_trash(sdk: &FlowySDKTest) -> RepeatedTrashPB {