refactor: rename structs

frontend/rust-lib/dart-ffi/Cargo.toml

@@ -7,8 +7,8 @@ edition = "2018"
 [lib]
 name = "dart_ffi"
 # this value will change depending on the target os
-# default staticlib
-crate-type = ["staticlib"]
+# default cdylib
+crate-type = ["cdylib"]
 
 
 [dependencies]

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

@@ -1,8 +1,8 @@
-use crate::queue::DocumentRevisionCompact;
-use crate::web_socket::{make_document_ws_manager, EditorCommandSender};
+use crate::queue::BlockRevisionCompact;
+use crate::web_socket::{make_block_ws_manager, EditorCommandSender};
 use crate::{
     errors::FlowyError,
-    queue::{EditorCommand, EditorCommandQueue},
+    queue::{EditBlockQueue, EditorCommand},
     BlockUser,
 };
 use bytes::Bytes;
@@ -41,7 +41,7 @@ impl ClientBlockEditor {
         cloud_service: Arc<dyn RevisionCloudService>,
     ) -> FlowyResult<Arc<Self>> {
         let document_info = rev_manager
-            .load::<BlockInfoBuilder, DocumentRevisionCompact>(cloud_service)
+            .load::<BlockInfoBuilder, BlockRevisionCompact>(cloud_service)
             .await?;
         let delta = document_info.delta()?;
         let rev_manager = Arc::new(rev_manager);
@@ -49,7 +49,7 @@ impl ClientBlockEditor {
         let user_id = user.user_id()?;
 
         let edit_cmd_tx = spawn_edit_queue(user, rev_manager.clone(), delta);
-        let ws_manager = make_document_ws_manager(
+        let ws_manager = make_block_ws_manager(
             doc_id.clone(),
             user_id.clone(),
             edit_cmd_tx.clone(),
@@ -176,7 +176,7 @@ impl ClientBlockEditor {
 
 impl std::ops::Drop for ClientBlockEditor {
     fn drop(&mut self) {
-        tracing::trace!("{} ClientDocumentEditor was dropped", self.doc_id)
+        tracing::trace!("{} ClientBlockEditor was dropped", self.doc_id)
     }
 }
 
@@ -187,8 +187,8 @@ fn spawn_edit_queue(
     delta: RichTextDelta,
 ) -> EditorCommandSender {
     let (sender, receiver) = mpsc::channel(1000);
-    let actor = EditorCommandQueue::new(user, rev_manager, delta, receiver);
-    tokio::spawn(actor.run());
+    let edit_queue = EditBlockQueue::new(user, rev_manager, delta, receiver);
+    tokio::spawn(edit_queue.run());
     sender
 }
 

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

@@ -1,4 +1,4 @@
-pub mod editor;
+pub mod block_editor;
 pub mod manager;
 mod queue;
 mod web_socket;

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

@@ -1,4 +1,4 @@
-use crate::{editor::ClientBlockEditor, errors::FlowyError, BlockCloudService};
+use crate::{block_editor::ClientBlockEditor, errors::FlowyError, BlockCloudService};
 use bytes::Bytes;
 use dashmap::DashMap;
 use flowy_collaboration::entities::{
@@ -22,27 +22,27 @@ pub trait BlockUser: Send + Sync {
 pub struct BlockManager {
     cloud_service: Arc<dyn BlockCloudService>,
     rev_web_socket: Arc<dyn RevisionWebSocket>,
-    block_handlers: Arc<BlockEditorHandlers>,
-    document_user: Arc<dyn BlockUser>,
+    block_editors: Arc<BlockEditors>,
+    block_user: Arc<dyn BlockUser>,
 }
 
 impl BlockManager {
     pub fn new(
         cloud_service: Arc<dyn BlockCloudService>,
-        document_user: Arc<dyn BlockUser>,
+        block_user: Arc<dyn BlockUser>,
         rev_web_socket: Arc<dyn RevisionWebSocket>,
     ) -> Self {
-        let block_handlers = Arc::new(BlockEditorHandlers::new());
+        let block_handlers = Arc::new(BlockEditors::new());
         Self {
             cloud_service,
             rev_web_socket,
-            block_handlers,
-            document_user,
+            block_editors: block_handlers,
+            block_user,
         }
     }
 
     pub fn init(&self) -> FlowyResult<()> {
-        listen_ws_state_changed(self.rev_web_socket.clone(), self.block_handlers.clone());
+        listen_ws_state_changed(self.rev_web_socket.clone(), self.block_editors.clone());
 
         Ok(())
     }
@@ -58,7 +58,7 @@ impl BlockManager {
     pub fn close_block<T: AsRef<str>>(&self, block_id: T) -> Result<(), FlowyError> {
         let block_id = block_id.as_ref();
         tracing::Span::current().record("block_id", &block_id);
-        self.block_handlers.remove(block_id);
+        self.block_editors.remove(block_id);
         Ok(())
     }
 
@@ -66,7 +66,7 @@ impl BlockManager {
     pub fn delete<T: AsRef<str>>(&self, doc_id: T) -> Result<(), FlowyError> {
         let doc_id = doc_id.as_ref();
         tracing::Span::current().record("doc_id", &doc_id);
-        self.block_handlers.remove(doc_id);
+        self.block_editors.remove(doc_id);
         Ok(())
     }
 
@@ -83,7 +83,7 @@ impl BlockManager {
 
     pub async fn reset_with_revisions<T: AsRef<str>>(&self, doc_id: T, revisions: RepeatedRevision) -> FlowyResult<()> {
         let doc_id = doc_id.as_ref().to_owned();
-        let db_pool = self.document_user.db_pool()?;
+        let db_pool = self.block_user.db_pool()?;
         let rev_manager = self.make_rev_manager(&doc_id, db_pool)?;
         let _ = rev_manager.reset_object(revisions).await?;
         Ok(())
@@ -92,7 +92,7 @@ impl BlockManager {
     pub async fn receive_ws_data(&self, data: Bytes) {
         let result: Result<ServerRevisionWSData, protobuf::ProtobufError> = data.try_into();
         match result {
-            Ok(data) => match self.block_handlers.get(&data.object_id) {
+            Ok(data) => match self.block_editors.get(&data.object_id) {
                 None => tracing::error!("Can't find any source handler for {:?}-{:?}", data.object_id, data.ty),
                 Some(block_editor) => match block_editor.receive_ws_data(data).await {
                     Ok(_) => {}
@@ -108,9 +108,9 @@ impl BlockManager {
 
 impl BlockManager {
     async fn get_block_editor(&self, block_id: &str) -> FlowyResult<Arc<ClientBlockEditor>> {
-        match self.block_handlers.get(block_id) {
+        match self.block_editors.get(block_id) {
             None => {
-                let db_pool = self.document_user.db_pool()?;
+                let db_pool = self.block_user.db_pool()?;
                 self.make_block_editor(block_id, db_pool).await
             }
             Some(editor) => Ok(editor),
@@ -122,32 +122,32 @@ impl BlockManager {
         block_id: &str,
         pool: Arc<ConnectionPool>,
     ) -> Result<Arc<ClientBlockEditor>, FlowyError> {
-        let user = self.document_user.clone();
-        let token = self.document_user.token()?;
+        let user = self.block_user.clone();
+        let token = self.block_user.token()?;
         let rev_manager = self.make_rev_manager(block_id, pool.clone())?;
-        let cloud_service = Arc::new(DocumentRevisionCloudServiceImpl {
+        let cloud_service = Arc::new(BlockRevisionCloudService {
             token,
             server: self.cloud_service.clone(),
         });
         let doc_editor =
             ClientBlockEditor::new(block_id, user, rev_manager, self.rev_web_socket.clone(), cloud_service).await?;
-        self.block_handlers.insert(block_id, &doc_editor);
+        self.block_editors.insert(block_id, &doc_editor);
         Ok(doc_editor)
     }
 
     fn make_rev_manager(&self, doc_id: &str, pool: Arc<ConnectionPool>) -> Result<RevisionManager, FlowyError> {
-        let user_id = self.document_user.user_id()?;
+        let user_id = self.block_user.user_id()?;
         let rev_persistence = Arc::new(RevisionPersistence::new(&user_id, doc_id, pool));
         Ok(RevisionManager::new(&user_id, doc_id, rev_persistence))
     }
 }
 
-struct DocumentRevisionCloudServiceImpl {
+struct BlockRevisionCloudService {
     token: String,
     server: Arc<dyn BlockCloudService>,
 }
 
-impl RevisionCloudService for DocumentRevisionCloudServiceImpl {
+impl RevisionCloudService for BlockRevisionCloudService {
     #[tracing::instrument(level = "trace", skip(self))]
     fn fetch_object(&self, user_id: &str, object_id: &str) -> FutureResult<Vec<Revision>, FlowyError> {
         let params: BlockId = object_id.to_string().into();
@@ -170,11 +170,11 @@ impl RevisionCloudService for DocumentRevisionCloudServiceImpl {
     }
 }
 
-pub struct BlockEditorHandlers {
+pub struct BlockEditors {
     inner: DashMap<String, Arc<ClientBlockEditor>>,
 }
 
-impl BlockEditorHandlers {
+impl BlockEditors {
     fn new() -> Self {
         Self { inner: DashMap::new() }
     }
@@ -207,7 +207,7 @@ impl BlockEditorHandlers {
 }
 
 #[tracing::instrument(level = "trace", skip(web_socket, handlers))]
-fn listen_ws_state_changed(web_socket: Arc<dyn RevisionWebSocket>, handlers: Arc<BlockEditorHandlers>) {
+fn listen_ws_state_changed(web_socket: Arc<dyn RevisionWebSocket>, handlers: Arc<BlockEditors>) {
     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

@@ -19,14 +19,14 @@ use tokio::sync::{oneshot, RwLock};
 
 // The EditorCommandQueue executes each command that will alter the document in
 // serial.
-pub(crate) struct EditorCommandQueue {
+pub(crate) struct EditBlockQueue {
     document: Arc<RwLock<ClientDocument>>,
     user: Arc<dyn BlockUser>,
     rev_manager: Arc<RevisionManager>,
     receiver: Option<EditorCommandReceiver>,
 }
 
-impl EditorCommandQueue {
+impl EditBlockQueue {
     pub(crate) fn new(
         user: Arc<dyn BlockUser>,
         rev_manager: Arc<RevisionManager>,
@@ -187,17 +187,17 @@ impl EditorCommandQueue {
         );
         let _ = self
             .rev_manager
-            .add_local_revision::<DocumentRevisionCompact>(&revision)
+            .add_local_revision::<BlockRevisionCompact>(&revision)
             .await?;
         Ok(rev_id.into())
     }
 }
 
-pub(crate) struct DocumentRevisionCompact();
-impl RevisionCompact for DocumentRevisionCompact {
+pub(crate) struct BlockRevisionCompact();
+impl RevisionCompact for BlockRevisionCompact {
     fn compact_revisions(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 document's revisions"));
+            return Err(FlowyError::internal().context("Can't compact the empty block's revisions"));
         }
 
         if revisions.len() == 1 {

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

@@ -22,7 +22,7 @@ use tokio::sync::{
 pub(crate) type EditorCommandSender = Sender<EditorCommand>;
 pub(crate) type EditorCommandReceiver = Receiver<EditorCommand>;
 
-pub(crate) async fn make_document_ws_manager(
+pub(crate) async fn make_block_ws_manager(
     doc_id: String,
     user_id: String,
     edit_cmd_tx: EditorCommandSender,
@@ -41,7 +41,7 @@ pub(crate) async fn make_document_ws_manager(
     let ws_data_sink = Arc::new(BlockWSDataSink(ws_data_provider));
     let ping_duration = Duration::from_millis(DOCUMENT_SYNC_INTERVAL_IN_MILLIS);
     let ws_manager = Arc::new(RevisionWebSocketManager::new(
-        "Document",
+        "Block",
         &doc_id,
         rev_web_socket,
         ws_data_sink,

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

@@ -1,5 +1,5 @@
 use flowy_collaboration::entities::revision::RevisionState;
-use flowy_document::editor::ClientBlockEditor;
+use flowy_document::block_editor::ClientBlockEditor;
 use flowy_document::DOCUMENT_SYNC_INTERVAL_IN_MILLIS;
 use flowy_test::{helper::ViewTest, FlowySDKTest};
 use lib_ot::{core::Interval, rich_text::RichTextDelta};

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

@@ -17,7 +17,7 @@ use crate::{
     errors::FlowyResult,
     event_map::{FolderCouldServiceV1, WorkspaceDatabase, WorkspaceUser},
     services::{
-        folder_editor::FolderEditor, persistence::FolderPersistence, set_current_workspace, AppController,
+        folder_editor::ClientFolderEditor, persistence::FolderPersistence, set_current_workspace, AppController,
         TrashController, ViewController, WorkspaceController,
     },
 };
@@ -63,7 +63,7 @@ pub struct FolderManager {
     pub(crate) view_controller: Arc<ViewController>,
     pub(crate) trash_controller: Arc<TrashController>,
     web_socket: Arc<dyn RevisionWebSocket>,
-    folder_editor: Arc<TokioRwLock<Option<Arc<FolderEditor>>>>,
+    folder_editor: Arc<TokioRwLock<Option<Arc<ClientFolderEditor>>>>,
 }
 
 impl FolderManager {
@@ -162,7 +162,7 @@ impl FolderManager {
         let _ = self.persistence.initialize(user_id, &folder_id).await?;
 
         let pool = self.persistence.db_pool()?;
-        let folder_editor = FolderEditor::new(user_id, &folder_id, token, pool, self.web_socket.clone()).await?;
+        let folder_editor = ClientFolderEditor::new(user_id, &folder_id, token, pool, self.web_socket.clone()).await?;
         *self.folder_editor.write().await = Some(Arc::new(folder_editor));
 
         let _ = self.app_controller.initialize()?;
@@ -219,7 +219,7 @@ impl DefaultFolderBuilder {
 
 #[cfg(feature = "flowy_unit_test")]
 impl FolderManager {
-    pub async fn folder_editor(&self) -> Arc<FolderEditor> {
+    pub async fn folder_editor(&self) -> Arc<ClientFolderEditor> {
         self.folder_editor.read().await.clone().unwrap()
     }
 }

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

@@ -17,7 +17,7 @@ use lib_sqlite::ConnectionPool;
 use parking_lot::RwLock;
 use std::sync::Arc;
 
-pub struct FolderEditor {
+pub struct ClientFolderEditor {
     user_id: String,
     pub(crate) folder_id: FolderId,
     pub(crate) folder: Arc<RwLock<FolderPad>>,
@@ -25,7 +25,7 @@ pub struct FolderEditor {
     ws_manager: Arc<RevisionWebSocketManager>,
 }
 
-impl FolderEditor {
+impl ClientFolderEditor {
     pub async fn new(
         user_id: &str,
         folder_id: &FolderId,
@@ -35,7 +35,7 @@ impl FolderEditor {
     ) -> FlowyResult<Self> {
         let rev_persistence = Arc::new(RevisionPersistence::new(user_id, folder_id.as_ref(), pool));
         let mut rev_manager = RevisionManager::new(user_id, folder_id.as_ref(), rev_persistence);
-        let cloud = Arc::new(FolderRevisionCloudServiceImpl {
+        let cloud = Arc::new(FolderRevisionCloudService {
             token: token.to_string(),
         });
         let folder = Arc::new(RwLock::new(
@@ -109,12 +109,12 @@ impl RevisionObjectBuilder for FolderPadBuilder {
     }
 }
 
-struct FolderRevisionCloudServiceImpl {
+struct FolderRevisionCloudService {
     #[allow(dead_code)]
     token: String,
 }
 
-impl RevisionCloudService for FolderRevisionCloudServiceImpl {
+impl RevisionCloudService for FolderRevisionCloudService {
     #[tracing::instrument(level = "trace", skip(self))]
     fn fetch_object(&self, _user_id: &str, _object_id: &str) -> FutureResult<Vec<Revision>, FlowyError> {
         FutureResult::new(async move { Ok(vec![]) })
@@ -122,7 +122,7 @@ impl RevisionCloudService for FolderRevisionCloudServiceImpl {
 }
 
 #[cfg(feature = "flowy_unit_test")]
-impl FolderEditor {
+impl ClientFolderEditor {
     pub fn rev_manager(&self) -> Arc<RevisionManager> {
         self.rev_manager.clone()
     }

frontend/rust-lib/flowy-folder/src/services/persistence/mod.rs

@@ -13,7 +13,7 @@ pub use version_1::{app_sql::*, trash_sql::*, v1_impl::V1Transaction, view_sql::
 use crate::{
     controller::FolderId,
     event_map::WorkspaceDatabase,
-    services::{folder_editor::FolderEditor, persistence::migration::FolderMigration},
+    services::{folder_editor::ClientFolderEditor, persistence::migration::FolderMigration},
 };
 use flowy_error::{FlowyError, FlowyResult};
 use flowy_folder_data_model::entities::{
@@ -50,11 +50,14 @@ pub trait FolderPersistenceTransaction {
 
 pub struct FolderPersistence {
     database: Arc<dyn WorkspaceDatabase>,
-    folder_editor: Arc<RwLock<Option<Arc<FolderEditor>>>>,
+    folder_editor: Arc<RwLock<Option<Arc<ClientFolderEditor>>>>,
 }
 
 impl FolderPersistence {
-    pub fn new(database: Arc<dyn WorkspaceDatabase>, folder_editor: Arc<RwLock<Option<Arc<FolderEditor>>>>) -> Self {
+    pub fn new(
+        database: Arc<dyn WorkspaceDatabase>,
+        folder_editor: Arc<RwLock<Option<Arc<ClientFolderEditor>>>>,
+    ) -> Self {
         Self {
             database,
             folder_editor,

frontend/rust-lib/flowy-folder/src/services/persistence/version_2/v2_impl.rs

@@ -1,5 +1,5 @@
 use crate::services::{
-    folder_editor::FolderEditor,
+    folder_editor::ClientFolderEditor,
     persistence::{AppChangeset, FolderPersistenceTransaction, ViewChangeset, WorkspaceChangeset},
 };
 use flowy_error::{FlowyError, FlowyResult};
@@ -11,7 +11,7 @@ use flowy_folder_data_model::entities::{
 };
 use std::sync::Arc;
 
-impl FolderPersistenceTransaction for FolderEditor {
+impl FolderPersistenceTransaction for ClientFolderEditor {
     fn create_workspace(&self, _user_id: &str, workspace: Workspace) -> FlowyResult<()> {
         if let Some(change) = self.folder.write().create_workspace(workspace)? {
             let _ = self.apply_change(change)?;

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

@@ -1,6 +1,6 @@
 use crate::helper::*;
 use flowy_collaboration::entities::{document_info::BlockInfo, revision::RevisionState};
-use flowy_folder::{errors::ErrorCode, services::folder_editor::FolderEditor};
+use flowy_folder::{errors::ErrorCode, services::folder_editor::ClientFolderEditor};
 use flowy_folder_data_model::entities::{
     app::{App, RepeatedApp},
     trash::Trash,
@@ -95,7 +95,7 @@ impl FolderTest {
 
     pub async fn run_script(&mut self, script: FolderScript) {
         let sdk = &self.sdk;
-        let folder_editor: Arc<FolderEditor> = sdk.folder_manager.folder_editor().await;
+        let folder_editor: Arc<ClientFolderEditor> = sdk.folder_manager.folder_editor().await;
         let rev_manager = folder_editor.rev_manager();
         let cache = rev_manager.revision_cache().await;
 

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

@@ -24,7 +24,7 @@ impl DocumentDepsResolver {
         user_session: Arc<UserSession>,
         server_config: &ClientServerConfiguration,
     ) -> Arc<BlockManager> {
-        let user = Arc::new(DocumentUserImpl(user_session));
+        let user = Arc::new(BlockUserImpl(user_session));
         let ws_sender = Arc::new(BlockWebSocket(ws_conn.clone()));
         let cloud_service: Arc<dyn BlockCloudService> = match local_server {
             None => Arc::new(BlockHttpCloudService::new(server_config.clone())),
@@ -39,8 +39,8 @@ impl DocumentDepsResolver {
     }
 }
 
-struct DocumentUserImpl(Arc<UserSession>);
-impl BlockUser for DocumentUserImpl {
+struct BlockUserImpl(Arc<UserSession>);
+impl BlockUser for BlockUserImpl {
     fn user_dir(&self) -> Result<String, FlowyError> {
         let dir = self.0.user_dir().map_err(|e| FlowyError::unauthorized().context(e))?;
 

frontend/rust-lib/flowy-sync/src/cache/mod.rs

@@ -23,7 +23,7 @@ pub struct RevisionPersistence {
     object_id: String,
     disk_cache: Arc<dyn RevisionDiskCache<Error = FlowyError>>,
     memory_cache: Arc<RevisionMemoryCache>,
-    sync_seq: RwLock<SyncSequence>,
+    sync_seq: RwLock<RevisionSyncSequence>,
 }
 impl RevisionPersistence {
     pub fn new(user_id: &str, object_id: &str, pool: Arc<ConnectionPool>) -> RevisionPersistence {
@@ -31,7 +31,7 @@ impl RevisionPersistence {
         let memory_cache = Arc::new(RevisionMemoryCache::new(object_id, Arc::new(disk_cache.clone())));
         let object_id = object_id.to_owned();
         let user_id = user_id.to_owned();
-        let sync_seq = RwLock::new(SyncSequence::new());
+        let sync_seq = RwLock::new(RevisionSyncSequence::new());
         Self {
             user_id,
             object_id,
@@ -261,10 +261,10 @@ impl RevisionRecord {
 }
 
 #[derive(Default)]
-struct SyncSequence(VecDeque<i64>);
-impl SyncSequence {
+struct RevisionSyncSequence(VecDeque<i64>);
+impl RevisionSyncSequence {
     fn new() -> Self {
-        SyncSequence::default()
+        RevisionSyncSequence::default()
     }
 
     fn add(&mut self, new_rev_id: i64) -> FlowyResult<()> {