chore: rename crate

frontend/app_flowy/lib/plugins/doc/application/doc_service.dart

@@ -4,16 +4,16 @@ import 'package:flowy_sdk/dispatch/dispatch.dart';
 import 'package:flowy_sdk/protobuf/flowy-folder/view.pb.dart';
 import 'package:flowy_sdk/protobuf/flowy-error/errors.pb.dart';
 import 'package:flowy_sdk/protobuf/flowy-sync/text_block.pb.dart';
-import 'package:flowy_sdk/protobuf/flowy-text-block/entities.pb.dart';
+import 'package:flowy_sdk/protobuf/flowy-document/entities.pb.dart';
 
 class DocumentService {
-  Future<Either<TextBlockPB, FlowyError>> openDocument({
+  Future<Either<DocumentSnapshotPB, FlowyError>> openDocument({
     required String docId,
   }) async {
     await FolderEventSetLatestView(ViewIdPB(value: docId)).send();
 
-    final payload = TextBlockIdPB(value: docId);
-    return TextBlockEventGetTextBlock(payload).send();
+    final payload = DocumentIdPB(value: docId);
+    return DocumentEventGetDocument(payload).send();
   }
 
   Future<Either<Unit, FlowyError>> applyEdit({
@@ -22,10 +22,10 @@ class DocumentService {
     String operations = "",
   }) {
     final payload = EditPayloadPB.create()
-      ..textBlockId = docId
+      ..docId = docId
       ..operations = operations
-      ..delta = data;
-    return TextBlockEventApplyEdit(payload).send();
+      ..operationsStr = data;
+    return DocumentEventApplyEdit(payload).send();
   }
 
   Future<Either<Unit, FlowyError>> closeDocument({required String docId}) {

frontend/app_flowy/lib/plugins/doc/application/share_bloc.dart

@@ -3,7 +3,7 @@ import 'dart:io';
 import 'package:app_flowy/startup/tasks/rust_sdk.dart';
 import 'package:app_flowy/workspace/application/markdown/delta_markdown.dart';
 import 'package:app_flowy/plugins/doc/application/share_service.dart';
-import 'package:flowy_sdk/protobuf/flowy-text-block/entities.pb.dart';
+import 'package:flowy_sdk/protobuf/flowy-document/entities.pb.dart';
 import 'package:flowy_sdk/protobuf/flowy-folder/view.pb.dart';
 import 'package:flowy_sdk/protobuf/flowy-error/errors.pb.dart';
 import 'package:freezed_annotation/freezed_annotation.dart';

frontend/app_flowy/lib/plugins/doc/application/share_service.dart

@@ -2,15 +2,16 @@ import 'dart:async';
 import 'package:dartz/dartz.dart';
 import 'package:flowy_sdk/dispatch/dispatch.dart';
 import 'package:flowy_sdk/protobuf/flowy-error/errors.pb.dart';
-import 'package:flowy_sdk/protobuf/flowy-text-block/protobuf.dart';
+import 'package:flowy_sdk/protobuf/flowy-document/protobuf.dart';
 
 class ShareService {
-  Future<Either<ExportDataPB, FlowyError>> export(String docId, ExportType type) {
+  Future<Either<ExportDataPB, FlowyError>> export(
+      String docId, ExportType type) {
     final request = ExportPayloadPB.create()
       ..viewId = docId
       ..exportType = type;
 
-    return TextBlockEventExportDocument(request).send();
+    return DocumentEventExportDocument(request).send();
   }
 
   Future<Either<ExportDataPB, FlowyError>> exportText(String docId) {

frontend/app_flowy/lib/plugins/doc/document.dart

@@ -20,7 +20,7 @@ import 'package:flowy_infra_ui/widget/rounded_button.dart';
 import 'package:flowy_sdk/log.dart';
 import 'package:flowy_sdk/protobuf/flowy-error/errors.pb.dart';
 import 'package:flowy_sdk/protobuf/flowy-folder/view.pb.dart';
-import 'package:flowy_sdk/protobuf/flowy-text-block/entities.pb.dart';
+import 'package:flowy_sdk/protobuf/flowy-document/entities.pb.dart';
 import 'package:flutter/material.dart';
 import 'package:flutter_bloc/flutter_bloc.dart';
 import 'package:provider/provider.dart';

frontend/app_flowy/packages/flowy_sdk/lib/dispatch/dispatch.dart

@@ -16,7 +16,7 @@ import 'package:flowy_sdk/ffi.dart' as ffi;
 import 'package:flowy_sdk/protobuf/flowy-user/protobuf.dart';
 import 'package:flowy_sdk/protobuf/dart-ffi/protobuf.dart';
 import 'package:flowy_sdk/protobuf/flowy-folder/protobuf.dart';
-import 'package:flowy_sdk/protobuf/flowy-text-block/protobuf.dart';
+import 'package:flowy_sdk/protobuf/flowy-document/protobuf.dart';
 import 'package:flowy_sdk/protobuf/flowy-grid/protobuf.dart';
 import 'package:flowy_sdk/protobuf/flowy-sync/protobuf.dart';
 
@@ -30,7 +30,7 @@ part 'dart_event/flowy-folder/dart_event.dart';
 part 'dart_event/flowy-net/dart_event.dart';
 part 'dart_event/flowy-user/dart_event.dart';
 part 'dart_event/flowy-grid/dart_event.dart';
-part 'dart_event/flowy-text-block/dart_event.dart';
+part 'dart_event/flowy-document/dart_event.dart';
 
 enum FFIException {
   RequestIsEmpty,
@@ -56,7 +56,8 @@ class Dispatch {
   }
 }
 
-Future<Either<Uint8List, Uint8List>> _extractPayload(Future<Either<FFIResponse, FlowyInternalError>> responseFuture) {
+Future<Either<Uint8List, Uint8List>> _extractPayload(
+    Future<Either<FFIResponse, FlowyInternalError>> responseFuture) {
   return responseFuture.then((result) {
     return result.fold(
       (response) {
@@ -82,7 +83,8 @@ Future<Either<Uint8List, Uint8List>> _extractPayload(Future<Either<FFIResponse,
   });
 }
 
-Future<Either<FFIResponse, FlowyInternalError>> _extractResponse(Completer<Uint8List> bytesFuture) {
+Future<Either<FFIResponse, FlowyInternalError>> _extractResponse(
+    Completer<Uint8List> bytesFuture) {
   return bytesFuture.future.then((bytes) {
     try {
       final response = FFIResponse.fromBuffer(bytes);

frontend/rust-lib/Cargo.lock

@@ -843,6 +843,47 @@ dependencies = [
  "walkdir",
 ]
 
+[[package]]
+name = "flowy-document"
+version = "0.1.0"
+dependencies = [
+ "async-stream",
+ "bytes",
+ "chrono",
+ "color-eyre",
+ "criterion",
+ "dart-notify",
+ "dashmap",
+ "derive_more",
+ "diesel",
+ "diesel_derives",
+ "flowy-database",
+ "flowy-derive",
+ "flowy-document",
+ "flowy-error",
+ "flowy-revision",
+ "flowy-sync",
+ "flowy-test",
+ "futures",
+ "futures-util",
+ "lib-dispatch",
+ "lib-infra",
+ "lib-ot",
+ "lib-ws",
+ "log",
+ "protobuf",
+ "rand 0.8.5",
+ "serde",
+ "serde_json",
+ "strum",
+ "strum_macros",
+ "tokio",
+ "tracing",
+ "tracing-subscriber",
+ "unicode-segmentation",
+ "url",
+]
+
 [[package]]
 name = "flowy-error"
 version = "0.1.0"
@@ -882,13 +923,13 @@ dependencies = [
  "diesel_derives",
  "flowy-database",
  "flowy-derive",
+ "flowy-document",
  "flowy-error",
  "flowy-folder",
  "flowy-folder-data-model",
  "flowy-revision",
  "flowy-sync",
  "flowy-test",
- "flowy-text-block",
  "futures",
  "lazy_static",
  "lib-dispatch",
@@ -995,11 +1036,11 @@ dependencies = [
  "config",
  "dashmap",
  "flowy-derive",
+ "flowy-document",
  "flowy-error",
  "flowy-folder",
  "flowy-folder-data-model",
  "flowy-sync",
- "flowy-text-block",
  "flowy-user",
  "futures-util",
  "http-flowy",
@@ -1055,13 +1096,13 @@ dependencies = [
  "claim 0.5.0",
  "color-eyre",
  "flowy-database",
+ "flowy-document",
  "flowy-folder",
  "flowy-grid",
  "flowy-grid-data-model",
  "flowy-net",
  "flowy-revision",
  "flowy-sync",
- "flowy-text-block",
  "flowy-user",
  "futures-core",
  "futures-util",
@@ -1136,47 +1177,6 @@ dependencies = [
  "tokio",
 ]
 
-[[package]]
-name = "flowy-text-block"
-version = "0.1.0"
-dependencies = [
- "async-stream",
- "bytes",
- "chrono",
- "color-eyre",
- "criterion",
- "dart-notify",
- "dashmap",
- "derive_more",
- "diesel",
- "diesel_derives",
- "flowy-database",
- "flowy-derive",
- "flowy-error",
- "flowy-revision",
- "flowy-sync",
- "flowy-test",
- "flowy-text-block",
- "futures",
- "futures-util",
- "lib-dispatch",
- "lib-infra",
- "lib-ot",
- "lib-ws",
- "log",
- "protobuf",
- "rand 0.8.5",
- "serde",
- "serde_json",
- "strum",
- "strum_macros",
- "tokio",
- "tracing",
- "tracing-subscriber",
- "unicode-segmentation",
- "url",
-]
-
 [[package]]
 name = "flowy-user"
 version = "0.1.0"

frontend/rust-lib/Cargo.toml

@@ -11,7 +11,7 @@ members = [
   "flowy-database",
   "flowy-folder",
   "dart-notify",
-  "flowy-text-block",
+  "flowy-document",
   "flowy-error",
   "flowy-revision",
   "flowy-grid",

frontend/rust-lib/flowy-text-block/Cargo.toml → frontend/rust-lib/flowy-document/Cargo.toml

@@ -1,6 +1,6 @@
 
 [package]
-name = "flowy-text-block"
+name = "flowy-document"
 version = "0.1.0"
 edition = "2018"
 
@@ -41,7 +41,7 @@ futures = "0.3.15"
 
 [dev-dependencies]
 flowy-test = { path = "../flowy-test" }
-flowy-text-block = { path = "../flowy-text-block", features = ["flowy_unit_test"]}
+flowy-document = { path = "../flowy-document", features = ["flowy_unit_test"]}
 derive_more = {version = "0.99", features = ["display"]}
 tracing-subscriber = "0.2.0"
 

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

@@ -1,15 +1,15 @@
 use crate::web_socket::EditorCommandSender;
 use crate::{
     errors::FlowyError,
-    queue::{EditBlockQueue, EditorCommand},
-    TextEditorUser,
+    queue::{EditDocumentQueue, EditorCommand},
+    DocumentUser,
 };
 use bytes::Bytes;
 use flowy_error::{internal_error, FlowyResult};
 use flowy_revision::{RevisionCloudService, RevisionManager, RevisionObjectBuilder, RevisionWebSocket};
 use flowy_sync::entities::ws_data::ServerRevisionWSData;
 use flowy_sync::{
-    entities::{revision::Revision, text_block::DocumentPB},
+    entities::{revision::Revision, text_block::DocumentPayloadPB},
     errors::CollaborateResult,
     util::make_operations_from_revisions,
 };
@@ -22,7 +22,7 @@ use lib_ws::WSConnectState;
 use std::sync::Arc;
 use tokio::sync::{mpsc, oneshot};
 
-pub struct TextBlockEditor {
+pub struct DocumentEditor {
     pub doc_id: String,
     #[allow(dead_code)]
     rev_manager: Arc<RevisionManager>,
@@ -31,16 +31,16 @@ pub struct TextBlockEditor {
     edit_cmd_tx: EditorCommandSender,
 }
 
-impl TextBlockEditor {
+impl DocumentEditor {
     #[allow(unused_variables)]
     pub(crate) async fn new(
         doc_id: &str,
-        user: Arc<dyn TextEditorUser>,
+        user: Arc<dyn DocumentUser>,
         mut rev_manager: RevisionManager,
         rev_web_socket: Arc<dyn RevisionWebSocket>,
         cloud_service: Arc<dyn RevisionCloudService>,
     ) -> FlowyResult<Arc<Self>> {
-        let document_info = rev_manager.load::<TextBlockInfoBuilder>(Some(cloud_service)).await?;
+        let document_info = rev_manager.load::<DocumentRevisionBuilder>(Some(cloud_service)).await?;
         let delta = document_info.delta()?;
         let rev_manager = Arc::new(rev_manager);
         let doc_id = doc_id.to_string();
@@ -48,7 +48,7 @@ impl TextBlockEditor {
 
         let edit_cmd_tx = spawn_edit_queue(user, rev_manager.clone(), delta);
         #[cfg(feature = "sync")]
-        let ws_manager = crate::web_socket::make_block_ws_manager(
+        let ws_manager = crate::web_socket::make_document_ws_manager(
             doc_id.clone(),
             user_id.clone(),
             edit_cmd_tx.clone(),
@@ -140,22 +140,19 @@ impl TextBlockEditor {
         Ok(())
     }
 
-    pub async fn delta_str(&self) -> FlowyResult<String> {
+    pub async fn get_operation_str(&self) -> FlowyResult<String> {
         let (ret, rx) = oneshot::channel::<CollaborateResult<String>>();
-        let msg = EditorCommand::ReadDeltaStr { ret };
+        let msg = EditorCommand::StringifyOperations { ret };
         let _ = self.edit_cmd_tx.send(msg).await;
         let json = rx.await.map_err(internal_error)??;
         Ok(json)
     }
 
     #[tracing::instrument(level = "trace", skip(self, data), err)]
-    pub(crate) async fn compose_local_delta(&self, data: Bytes) -> Result<(), FlowyError> {
-        let delta = TextOperations::from_bytes(&data)?;
+    pub(crate) async fn compose_local_operations(&self, data: Bytes) -> Result<(), FlowyError> {
+        let operations = TextOperations::from_bytes(&data)?;
         let (ret, rx) = oneshot::channel::<CollaborateResult<()>>();
-        let msg = EditorCommand::ComposeLocalDelta {
-            delta: delta.clone(),
-            ret,
-        };
+        let msg = EditorCommand::ComposeLocalOperations { operations, ret };
         let _ = self.edit_cmd_tx.send(msg).await;
         let _ = rx.await.map_err(internal_error)??;
         Ok(())
@@ -186,20 +183,20 @@ impl TextBlockEditor {
     pub(crate) fn receive_ws_state(&self, _state: &WSConnectState) {}
 }
 
-impl std::ops::Drop for TextBlockEditor {
+impl std::ops::Drop for DocumentEditor {
     fn drop(&mut self) {
-        tracing::trace!("{} ClientBlockEditor was dropped", self.doc_id)
+        tracing::trace!("{} DocumentEditor was dropped", self.doc_id)
     }
 }
 
 // The edit queue will exit after the EditorCommandSender was dropped.
 fn spawn_edit_queue(
-    user: Arc<dyn TextEditorUser>,
+    user: Arc<dyn DocumentUser>,
     rev_manager: Arc<RevisionManager>,
     delta: TextOperations,
 ) -> EditorCommandSender {
     let (sender, receiver) = mpsc::channel(1000);
-    let edit_queue = EditBlockQueue::new(user, rev_manager, delta, receiver);
+    let edit_queue = EditDocumentQueue::new(user, rev_manager, delta, receiver);
     // We can use tokio::task::spawn_local here by using tokio::spawn_blocking.
     // https://github.com/tokio-rs/tokio/issues/2095
     // tokio::task::spawn_blocking(move || {
@@ -214,10 +211,10 @@ fn spawn_edit_queue(
 }
 
 #[cfg(feature = "flowy_unit_test")]
-impl TextBlockEditor {
-    pub async fn text_block_delta(&self) -> FlowyResult<TextOperations> {
+impl DocumentEditor {
+    pub async fn document_operations(&self) -> FlowyResult<TextOperations> {
         let (ret, rx) = oneshot::channel::<CollaborateResult<TextOperations>>();
-        let msg = EditorCommand::ReadDelta { ret };
+        let msg = EditorCommand::ReadOperations { ret };
         let _ = self.edit_cmd_tx.send(msg).await;
         let delta = rx.await.map_err(internal_error)??;
         Ok(delta)
@@ -228,18 +225,18 @@ impl TextBlockEditor {
     }
 }
 
-struct TextBlockInfoBuilder();
-impl RevisionObjectBuilder for TextBlockInfoBuilder {
-    type Output = DocumentPB;
+struct DocumentRevisionBuilder();
+impl RevisionObjectBuilder for DocumentRevisionBuilder {
+    type Output = DocumentPayloadPB;
 
     fn build_object(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);
 
-        Result::<DocumentPB, FlowyError>::Ok(DocumentPB {
-            block_id: object_id.to_owned(),
-            text: delta.json_str(),
+        Result::<DocumentPayloadPB, FlowyError>::Ok(DocumentPayloadPB {
+            doc_id: object_id.to_owned(),
+            content: delta.json_str(),
             rev_id,
             base_rev_id,
         })

frontend/rust-lib/flowy-text-block/src/entities.rs → frontend/rust-lib/flowy-document/src/entities.rs

@@ -32,7 +32,7 @@ impl std::convert::From<i32> for ExportType {
 #[derive(Default, ProtoBuf)]
 pub struct EditPayloadPB {
     #[pb(index = 1)]
-    pub text_block_id: String,
+    pub doc_id: String,
 
     // Encode in JSON format
     #[pb(index = 2)]
@@ -40,35 +40,35 @@ pub struct EditPayloadPB {
 
     // Encode in JSON format
     #[pb(index = 3)]
-    pub delta: String,
+    pub operations_str: String,
 }
 
 #[derive(Default)]
 pub struct EditParams {
-    pub text_block_id: String,
+    pub doc_id: String,
 
     // Encode in JSON format
     pub operations: String,
 
     // Encode in JSON format
-    pub delta: String,
+    pub operations_str: String,
 }
 
 impl TryInto<EditParams> for EditPayloadPB {
     type Error = ErrorCode;
     fn try_into(self) -> Result<EditParams, Self::Error> {
         Ok(EditParams {
-            text_block_id: self.text_block_id,
+            doc_id: self.doc_id,
             operations: self.operations,
-            delta: self.delta,
+            operations_str: self.operations_str,
         })
     }
 }
 
 #[derive(Default, ProtoBuf)]
-pub struct TextBlockPB {
+pub struct DocumentSnapshotPB {
     #[pb(index = 1)]
-    pub text_block_id: String,
+    pub doc_id: String,
 
     /// Encode in JSON format
     #[pb(index = 2)]

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

@@ -0,0 +1,43 @@
+use crate::entities::{DocumentSnapshotPB, EditParams, EditPayloadPB, ExportDataPB, ExportParams, ExportPayloadPB};
+use crate::DocumentEditorManager;
+use flowy_error::FlowyError;
+use flowy_sync::entities::text_block::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>>,
+) -> DataResult<DocumentSnapshotPB, FlowyError> {
+    let document_id: DocumentIdPB = data.into_inner();
+    let editor = manager.open_document_editor(&document_id).await?;
+    let operations_str = editor.get_operation_str().await?;
+    data_result(DocumentSnapshotPB {
+        doc_id: document_id.into(),
+        snapshot: operations_str,
+    })
+}
+
+pub(crate) async fn apply_edit_handler(
+    data: Data<EditPayloadPB>,
+    manager: AppData<Arc<DocumentEditorManager>>,
+) -> Result<(), FlowyError> {
+    let params: EditParams = data.into_inner().try_into()?;
+    let _ = manager.apply_edit(params).await?;
+    Ok(())
+}
+
+#[tracing::instrument(level = "debug", skip(data, manager), err)]
+pub(crate) async fn export_handler(
+    data: Data<ExportPayloadPB>,
+    manager: AppData<Arc<DocumentEditorManager>>,
+) -> DataResult<ExportDataPB, FlowyError> {
+    let params: ExportParams = data.into_inner().try_into()?;
+    let editor = manager.open_document_editor(&params.view_id).await?;
+    let operations_str = editor.get_operation_str().await?;
+    data_result(ExportDataPB {
+        data: operations_str,
+        export_type: params.export_type,
+    })
+}

frontend/rust-lib/flowy-text-block/src/event_map.rs → frontend/rust-lib/flowy-document/src/event_map.rs

@@ -1,26 +1,26 @@
 use crate::event_handler::*;
-use crate::TextEditorManager;
+use crate::DocumentEditorManager;
 use flowy_derive::{Flowy_Event, ProtoBuf_Enum};
 use lib_dispatch::prelude::Module;
 use std::sync::Arc;
 use strum_macros::Display;
 
-pub fn create(block_manager: Arc<TextEditorManager>) -> Module {
-    let mut module = Module::new().name(env!("CARGO_PKG_NAME")).data(block_manager);
+pub fn create(document_manager: Arc<DocumentEditorManager>) -> Module {
+    let mut module = Module::new().name(env!("CARGO_PKG_NAME")).data(document_manager);
 
     module = module
-        .event(TextBlockEvent::GetTextBlock, get_text_block_handler)
-        .event(TextBlockEvent::ApplyEdit, apply_edit_handler)
-        .event(TextBlockEvent::ExportDocument, export_handler);
+        .event(DocumentEvent::GetDocument, get_document_handler)
+        .event(DocumentEvent::ApplyEdit, apply_edit_handler)
+        .event(DocumentEvent::ExportDocument, export_handler);
 
     module
 }
 
 #[derive(Clone, Copy, PartialEq, Eq, Debug, Display, Hash, ProtoBuf_Enum, Flowy_Event)]
 #[event_err = "FlowyError"]
-pub enum TextBlockEvent {
-    #[event(input = "TextBlockIdPB", output = "TextBlockPB")]
-    GetTextBlock = 0,
+pub enum DocumentEvent {
+    #[event(input = "DocumentIdPB", output = "DocumentSnapshotPB")]
+    GetDocument = 0,
 
     #[event(input = "EditPayloadPB")]
     ApplyEdit = 1,

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

@@ -0,0 +1,27 @@
+pub mod editor;
+mod entities;
+mod event_handler;
+pub mod event_map;
+pub mod manager;
+mod queue;
+mod web_socket;
+
+pub mod protobuf;
+pub use manager::*;
+pub mod errors {
+    pub use flowy_error::{internal_error, ErrorCode, FlowyError};
+}
+
+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 lib_infra::future::FutureResult;
+
+pub trait DocumentCloudService: Send + Sync {
+    fn create_document(&self, token: &str, params: CreateDocumentParams) -> FutureResult<(), FlowyError>;
+
+    fn fetch_document(&self, token: &str, params: DocumentIdPB) -> FutureResult<Option<DocumentPayloadPB>, FlowyError>;
+
+    fn update_document_content(&self, token: &str, params: ResetDocumentParams) -> FutureResult<(), FlowyError>;
+}

frontend/rust-lib/flowy-text-block/src/manager.rs → frontend/rust-lib/flowy-document/src/manager.rs

@@ -1,47 +1,47 @@
 use crate::entities::EditParams;
-use crate::queue::TextBlockRevisionCompactor;
-use crate::{editor::TextBlockEditor, errors::FlowyError, TextEditorCloudService};
+use crate::queue::DocumentRevisionCompactor;
+use crate::{editor::DocumentEditor, errors::FlowyError, DocumentCloudService};
 use bytes::Bytes;
 use dashmap::DashMap;
 use flowy_database::ConnectionPool;
 use flowy_error::FlowyResult;
-use flowy_revision::disk::SQLiteTextBlockRevisionPersistence;
+use flowy_revision::disk::SQLiteDocumentRevisionPersistence;
 use flowy_revision::{
     RevisionCloudService, RevisionManager, RevisionPersistence, RevisionWebSocket, SQLiteRevisionSnapshotPersistence,
 };
 use flowy_sync::entities::{
     revision::{md5, RepeatedRevision, Revision},
-    text_block::{TextBlockDeltaPB, TextBlockIdPB},
+    text_block::{DocumentIdPB, DocumentOperationsPB},
     ws_data::ServerRevisionWSData,
 };
 use lib_infra::future::FutureResult;
 use std::{convert::TryInto, sync::Arc};
 
-pub trait TextEditorUser: Send + Sync {
+pub trait DocumentUser: Send + Sync {
     fn user_dir(&self) -> Result<String, FlowyError>;
     fn user_id(&self) -> Result<String, FlowyError>;
     fn token(&self) -> Result<String, FlowyError>;
     fn db_pool(&self) -> Result<Arc<ConnectionPool>, FlowyError>;
 }
 
-pub struct TextEditorManager {
-    cloud_service: Arc<dyn TextEditorCloudService>,
+pub struct DocumentEditorManager {
+    cloud_service: Arc<dyn DocumentCloudService>,
     rev_web_socket: Arc<dyn RevisionWebSocket>,
     editor_map: Arc<TextEditorMap>,
-    user: Arc<dyn TextEditorUser>,
+    user: Arc<dyn DocumentUser>,
 }
 
-impl TextEditorManager {
+impl DocumentEditorManager {
     pub fn new(
-        cloud_service: Arc<dyn TextEditorCloudService>,
-        text_block_user: Arc<dyn TextEditorUser>,
+        cloud_service: Arc<dyn DocumentCloudService>,
+        document_user: Arc<dyn DocumentUser>,
         rev_web_socket: Arc<dyn RevisionWebSocket>,
     ) -> Self {
         Self {
             cloud_service,
             rev_web_socket,
             editor_map: Arc::new(TextEditorMap::new()),
-            user: text_block_user,
+            user: document_user,
         }
     }
 
@@ -52,10 +52,10 @@ impl TextEditorManager {
     }
 
     #[tracing::instrument(level = "trace", skip(self, editor_id), fields(editor_id), err)]
-    pub async fn open_text_editor<T: AsRef<str>>(&self, editor_id: T) -> Result<Arc<TextBlockEditor>, FlowyError> {
+    pub async fn open_document_editor<T: AsRef<str>>(&self, editor_id: T) -> Result<Arc<DocumentEditor>, FlowyError> {
         let editor_id = editor_id.as_ref();
         tracing::Span::current().record("editor_id", &editor_id);
-        self.get_text_editor(editor_id).await
+        self.get_document_editor(editor_id).await
     }
 
     #[tracing::instrument(level = "trace", skip(self, editor_id), fields(editor_id), err)]
@@ -66,32 +66,35 @@ impl TextEditorManager {
         Ok(())
     }
 
-    #[tracing::instrument(level = "debug", skip(self, delta), err)]
-    pub async fn receive_local_delta(&self, delta: TextBlockDeltaPB) -> Result<TextBlockDeltaPB, FlowyError> {
-        let editor = self.get_text_editor(&delta.text_block_id).await?;
-        let _ = editor.compose_local_delta(Bytes::from(delta.delta_str)).await?;
-        let delta_str = editor.delta_str().await?;
-        Ok(TextBlockDeltaPB {
-            text_block_id: delta.text_block_id.clone(),
-            delta_str,
+    #[tracing::instrument(level = "debug", skip(self, payload), err)]
+    pub async fn receive_local_operations(
+        &self,
+        payload: DocumentOperationsPB,
+    ) -> Result<DocumentOperationsPB, FlowyError> {
+        let editor = self.get_document_editor(&payload.doc_id).await?;
+        let _ = editor
+            .compose_local_operations(Bytes::from(payload.operations_str))
+            .await?;
+        let operations_str = editor.get_operation_str().await?;
+        Ok(DocumentOperationsPB {
+            doc_id: payload.doc_id.clone(),
+            operations_str,
         })
     }
 
     pub async fn apply_edit(&self, params: EditParams) -> FlowyResult<()> {
-        let editor = self.get_text_editor(&params.text_block_id).await?;
-        let _ = editor.compose_local_delta(Bytes::from(params.delta)).await?;
+        let editor = self.get_document_editor(&params.doc_id).await?;
+        let _ = editor
+            .compose_local_operations(Bytes::from(params.operations_str))
+            .await?;
         Ok(())
     }
 
-    pub async fn create_text_block<T: AsRef<str>>(
-        &self,
-        text_block_id: T,
-        revisions: RepeatedRevision,
-    ) -> FlowyResult<()> {
-        let doc_id = text_block_id.as_ref().to_owned();
+    pub async fn create_document<T: AsRef<str>>(&self, doc_id: T, revisions: RepeatedRevision) -> FlowyResult<()> {
+        let doc_id = doc_id.as_ref().to_owned();
         let db_pool = self.user.db_pool()?;
-        // Maybe we could save the block to disk without creating the RevisionManager
-        let rev_manager = self.make_text_block_rev_manager(&doc_id, db_pool)?;
+        // Maybe we could save the document to disk without creating the RevisionManager
+        let rev_manager = self.make_document_rev_manager(&doc_id, db_pool)?;
         let _ = rev_manager.reset_object(revisions).await?;
         Ok(())
     }
@@ -113,47 +116,46 @@ impl TextEditorManager {
     }
 }
 
-impl TextEditorManager {
-    async fn get_text_editor(&self, block_id: &str) -> FlowyResult<Arc<TextBlockEditor>> {
-        match self.editor_map.get(block_id) {
+impl DocumentEditorManager {
+    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_text_editor(block_id, db_pool).await
+                self.make_document_editor(doc_id, db_pool).await
             }
             Some(editor) => Ok(editor),
         }
     }
 
     #[tracing::instrument(level = "trace", skip(self, pool), err)]
-    async fn make_text_editor(
+    async fn make_document_editor(
         &self,
-        block_id: &str,
+        doc_id: &str,
         pool: Arc<ConnectionPool>,
-    ) -> Result<Arc<TextBlockEditor>, FlowyError> {
+    ) -> Result<Arc<DocumentEditor>, FlowyError> {
         let user = self.user.clone();
         let token = self.user.token()?;
-        let rev_manager = self.make_text_block_rev_manager(block_id, pool.clone())?;
-        let cloud_service = Arc::new(TextBlockRevisionCloudService {
+        let rev_manager = self.make_document_rev_manager(doc_id, pool.clone())?;
+        let cloud_service = Arc::new(DocumentRevisionCloudService {
             token,
             server: self.cloud_service.clone(),
         });
-        let doc_editor =
-            TextBlockEditor::new(block_id, user, rev_manager, self.rev_web_socket.clone(), cloud_service).await?;
-        self.editor_map.insert(block_id, &doc_editor);
-        Ok(doc_editor)
+        let editor = DocumentEditor::new(doc_id, user, rev_manager, self.rev_web_socket.clone(), cloud_service).await?;
+        self.editor_map.insert(doc_id, &editor);
+        Ok(editor)
     }
 
-    fn make_text_block_rev_manager(
+    fn make_document_rev_manager(
         &self,
         doc_id: &str,
         pool: Arc<ConnectionPool>,
     ) -> Result<RevisionManager, FlowyError> {
         let user_id = self.user.user_id()?;
-        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, doc_id, disk_cache);
         // let history_persistence = SQLiteRevisionHistoryPersistence::new(doc_id, pool.clone());
         let snapshot_persistence = SQLiteRevisionSnapshotPersistence::new(doc_id, pool);
-        let rev_compactor = TextBlockRevisionCompactor();
+        let rev_compactor = DocumentRevisionCompactor();
 
         Ok(RevisionManager::new(
             &user_id,
@@ -166,30 +168,30 @@ impl TextEditorManager {
     }
 }
 
-struct TextBlockRevisionCloudService {
+struct DocumentRevisionCloudService {
     token: String,
-    server: Arc<dyn TextEditorCloudService>,
+    server: Arc<dyn DocumentCloudService>,
 }
 
-impl RevisionCloudService for TextBlockRevisionCloudService {
+impl RevisionCloudService for DocumentRevisionCloudService {
     #[tracing::instrument(level = "trace", skip(self))]
     fn fetch_object(&self, user_id: &str, object_id: &str) -> FutureResult<Vec<Revision>, FlowyError> {
-        let params: TextBlockIdPB = object_id.to_string().into();
+        let params: DocumentIdPB = object_id.to_string().into();
         let server = self.server.clone();
         let token = self.token.clone();
         let user_id = user_id.to_string();
 
         FutureResult::new(async move {
-            match server.read_text_block(&token, params).await? {
+            match server.fetch_document(&token, params).await? {
                 None => Err(FlowyError::record_not_found().context("Remote doesn't have this document")),
-                Some(doc) => {
-                    let delta_data = Bytes::from(doc.text.clone());
-                    let doc_md5 = md5(&delta_data);
+                Some(payload) => {
+                    let bytes = Bytes::from(payload.content.clone());
+                    let doc_md5 = md5(&bytes);
                     let revision = Revision::new(
-                        &doc.block_id,
-                        doc.base_rev_id,
-                        doc.rev_id,
-                        delta_data,
+                        &payload.doc_id,
+                        payload.base_rev_id,
+                        payload.rev_id,
+                        bytes,
                         &user_id,
                         doc_md5,
                     );
@@ -201,7 +203,7 @@ impl RevisionCloudService for TextBlockRevisionCloudService {
 }
 
 pub struct TextEditorMap {
-    inner: DashMap<String, Arc<TextBlockEditor>>,
+    inner: DashMap<String, Arc<DocumentEditor>>,
 }
 
 impl TextEditorMap {
@@ -209,14 +211,14 @@ impl TextEditorMap {
         Self { inner: DashMap::new() }
     }
 
-    pub(crate) fn insert(&self, editor_id: &str, doc: &Arc<TextBlockEditor>) {
+    pub(crate) fn insert(&self, editor_id: &str, doc: &Arc<DocumentEditor>) {
         if self.inner.contains_key(editor_id) {
             log::warn!("Doc:{} already exists in cache", editor_id);
         }
         self.inner.insert(editor_id.to_string(), doc.clone());
     }
 
-    pub(crate) fn get(&self, editor_id: &str) -> Option<Arc<TextBlockEditor>> {
+    pub(crate) fn get(&self, editor_id: &str) -> Option<Arc<DocumentEditor>> {
         Some(self.inner.get(editor_id)?.clone())
     }
 

frontend/rust-lib/flowy-text-block/src/queue.rs → frontend/rust-lib/flowy-document/src/queue.rs

@@ -1,9 +1,9 @@
 use crate::web_socket::EditorCommandReceiver;
-use crate::TextEditorUser;
+use crate::DocumentUser;
 use async_stream::stream;
 use bytes::Bytes;
 use flowy_error::{FlowyError, FlowyResult};
-use flowy_revision::{OperationsMD5, RevisionCompactor, RevisionManager, RichTextTransformDeltas, TransformDeltas};
+use flowy_revision::{OperationsMD5, RevisionCompactor, RevisionManager, TextTransformOperations, TransformOperations};
 use flowy_sync::util::make_operations_from_revisions;
 use flowy_sync::{
     client_document::{history::UndoResult, ClientDocument},
@@ -21,21 +21,21 @@ use tokio::sync::{oneshot, RwLock};
 
 // The EditorCommandQueue executes each command that will alter the document in
 // serial.
-pub(crate) struct EditBlockQueue {
+pub(crate) struct EditDocumentQueue {
     document: Arc<RwLock<ClientDocument>>,
-    user: Arc<dyn TextEditorUser>,
+    user: Arc<dyn DocumentUser>,
     rev_manager: Arc<RevisionManager>,
     receiver: Option<EditorCommandReceiver>,
 }
 
-impl EditBlockQueue {
+impl EditDocumentQueue {
     pub(crate) fn new(
-        user: Arc<dyn TextEditorUser>,
+        user: Arc<dyn DocumentUser>,
         rev_manager: Arc<RevisionManager>,
-        delta: TextOperations,
+        operations: TextOperations,
         receiver: EditorCommandReceiver,
     ) -> Self {
-        let document = Arc::new(RwLock::new(ClientDocument::from_operations(delta)));
+        let document = Arc::new(RwLock::new(ClientDocument::from_operations(operations)));
         Self {
             document,
             user,
@@ -67,29 +67,29 @@ impl EditBlockQueue {
     #[tracing::instrument(level = "trace", skip(self), err)]
     async fn handle_command(&self, command: EditorCommand) -> Result<(), FlowyError> {
         match command {
-            EditorCommand::ComposeLocalDelta { delta, ret } => {
+            EditorCommand::ComposeLocalOperations { operations, ret } => {
                 let mut document = self.document.write().await;
-                let _ = document.compose_operations(delta.clone())?;
+                let _ = document.compose_operations(operations.clone())?;
                 let md5 = document.md5();
                 drop(document);
-                let _ = self.save_local_delta(delta, md5).await?;
+                let _ = self.save_local_operations(operations, md5).await?;
                 let _ = ret.send(Ok(()));
             }
-            EditorCommand::ComposeRemoteDelta { client_delta, ret } => {
+            EditorCommand::ComposeRemoteOperation { client_operations, ret } => {
                 let mut document = self.document.write().await;
-                let _ = document.compose_operations(client_delta.clone())?;
+                let _ = document.compose_operations(client_operations.clone())?;
                 let md5 = document.md5();
                 drop(document);
                 let _ = ret.send(Ok(md5));
             }
-            EditorCommand::ResetDelta { delta, ret } => {
+            EditorCommand::ResetOperations { operations, ret } => {
                 let mut document = self.document.write().await;
-                let _ = document.set_operations(delta);
+                let _ = document.set_operations(operations);
                 let md5 = document.md5();
                 drop(document);
                 let _ = ret.send(Ok(md5));
             }
-            EditorCommand::TransformDelta { delta, ret } => {
+            EditorCommand::TransformOperations { operations, ret } => {
                 let f = || async {
                     let read_guard = self.document.read().await;
                     let mut server_prime: Option<TextOperations> = None;
@@ -97,14 +97,14 @@ impl EditBlockQueue {
 
                     if read_guard.is_empty() {
                         // Do nothing
-                        client_prime = delta;
+                        client_prime = operations;
                     } else {
-                        let (s_prime, c_prime) = read_guard.get_operations().transform(&delta)?;
+                        let (s_prime, c_prime) = read_guard.get_operations().transform(&operations)?;
                         client_prime = c_prime;
                         server_prime = Some(s_prime);
                     }
                     drop(read_guard);
-                    Ok::<RichTextTransformDeltas, CollaborateError>(TransformDeltas {
+                    Ok::<TextTransformOperations, CollaborateError>(TransformOperations {
                         client_prime,
                         server_prime,
                     })
@@ -113,16 +113,16 @@ impl EditBlockQueue {
             }
             EditorCommand::Insert { index, data, ret } => {
                 let mut write_guard = self.document.write().await;
-                let delta = write_guard.insert(index, data)?;
+                let operations = write_guard.insert(index, data)?;
                 let md5 = write_guard.md5();
-                let _ = self.save_local_delta(delta, md5).await?;
+                let _ = self.save_local_operations(operations, md5).await?;
                 let _ = ret.send(Ok(()));
             }
             EditorCommand::Delete { interval, ret } => {
                 let mut write_guard = self.document.write().await;
-                let delta = write_guard.delete(interval)?;
+                let operations = write_guard.delete(interval)?;
                 let md5 = write_guard.md5();
-                let _ = self.save_local_delta(delta, md5).await?;
+                let _ = self.save_local_operations(operations, md5).await?;
                 let _ = ret.send(Ok(()));
             }
             EditorCommand::Format {
@@ -131,16 +131,16 @@ impl EditBlockQueue {
                 ret,
             } => {
                 let mut write_guard = self.document.write().await;
-                let delta = write_guard.format(interval, attribute)?;
+                let operations = write_guard.format(interval, attribute)?;
                 let md5 = write_guard.md5();
-                let _ = self.save_local_delta(delta, md5).await?;
+                let _ = self.save_local_operations(operations, md5).await?;
                 let _ = ret.send(Ok(()));
             }
             EditorCommand::Replace { interval, data, ret } => {
                 let mut write_guard = self.document.write().await;
-                let delta = write_guard.replace(interval, data)?;
+                let operations = write_guard.replace(interval, data)?;
                 let md5 = write_guard.md5();
-                let _ = self.save_local_delta(delta, md5).await?;
+                let _ = self.save_local_operations(operations, md5).await?;
                 let _ = ret.send(Ok(()));
             }
             EditorCommand::CanUndo { ret } => {
@@ -151,73 +151,66 @@ impl EditBlockQueue {
             }
             EditorCommand::Undo { ret } => {
                 let mut write_guard = self.document.write().await;
-                let UndoResult { operations: delta } = write_guard.undo()?;
+                let UndoResult { operations } = write_guard.undo()?;
                 let md5 = write_guard.md5();
-                let _ = self.save_local_delta(delta, md5).await?;
+                let _ = self.save_local_operations(operations, md5).await?;
                 let _ = ret.send(Ok(()));
             }
             EditorCommand::Redo { ret } => {
                 let mut write_guard = self.document.write().await;
-                let UndoResult { operations: delta } = write_guard.redo()?;
+                let UndoResult { operations } = write_guard.redo()?;
                 let md5 = write_guard.md5();
-                let _ = self.save_local_delta(delta, md5).await?;
+                let _ = self.save_local_operations(operations, md5).await?;
                 let _ = ret.send(Ok(()));
             }
-            EditorCommand::ReadDeltaStr { ret } => {
+            EditorCommand::StringifyOperations { ret } => {
                 let data = self.document.read().await.get_operations_json();
                 let _ = ret.send(Ok(data));
             }
-            EditorCommand::ReadDelta { ret } => {
-                let delta = self.document.read().await.get_operations().clone();
-                let _ = ret.send(Ok(delta));
+            EditorCommand::ReadOperations { ret } => {
+                let operations = self.document.read().await.get_operations().clone();
+                let _ = ret.send(Ok(operations));
             }
         }
         Ok(())
     }
 
-    async fn save_local_delta(&self, delta: TextOperations, md5: String) -> Result<RevId, FlowyError> {
-        let delta_data = delta.json_bytes();
+    async fn save_local_operations(&self, operations: TextOperations, md5: String) -> Result<RevId, FlowyError> {
+        let bytes = operations.json_bytes();
         let (base_rev_id, rev_id) = self.rev_manager.next_rev_id_pair();
         let user_id = self.user.user_id()?;
-        let revision = Revision::new(
-            &self.rev_manager.object_id,
-            base_rev_id,
-            rev_id,
-            delta_data,
-            &user_id,
-            md5,
-        );
+        let revision = Revision::new(&self.rev_manager.object_id, base_rev_id, rev_id, bytes, &user_id, md5);
         let _ = self.rev_manager.add_local_revision(&revision).await?;
         Ok(rev_id.into())
     }
 }
 
-pub(crate) struct TextBlockRevisionCompactor();
-impl RevisionCompactor for TextBlockRevisionCompactor {
+pub(crate) struct DocumentRevisionCompactor();
+impl RevisionCompactor for DocumentRevisionCompactor {
     fn bytes_from_revisions(&self, revisions: Vec<Revision>) -> FlowyResult<Bytes> {
-        let delta = make_operations_from_revisions::<AttributeHashMap>(revisions)?;
-        Ok(delta.json_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 {
-    ComposeLocalDelta {
-        delta: TextOperations,
+    ComposeLocalOperations {
+        operations: TextOperations,
         ret: Ret<()>,
     },
-    ComposeRemoteDelta {
-        client_delta: TextOperations,
+    ComposeRemoteOperation {
+        client_operations: TextOperations,
         ret: Ret<OperationsMD5>,
     },
-    ResetDelta {
-        delta: TextOperations,
+    ResetOperations {
+        operations: TextOperations,
         ret: Ret<OperationsMD5>,
     },
-    TransformDelta {
-        delta: TextOperations,
-        ret: Ret<RichTextTransformDeltas>,
+    TransformOperations {
+        operations: TextOperations,
+        ret: Ret<TextTransformOperations>,
     },
     Insert {
         index: usize,
@@ -250,11 +243,11 @@ pub(crate) enum EditorCommand {
     Redo {
         ret: Ret<()>,
     },
-    ReadDeltaStr {
+    StringifyOperations {
         ret: Ret<String>,
     },
     #[allow(dead_code)]
-    ReadDelta {
+    ReadOperations {
         ret: Ret<TextOperations>,
     },
 }
@@ -262,10 +255,10 @@ pub(crate) enum EditorCommand {
 impl std::fmt::Debug for EditorCommand {
     fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
         let s = match self {
-            EditorCommand::ComposeLocalDelta { .. } => "ComposeLocalDelta",
-            EditorCommand::ComposeRemoteDelta { .. } => "ComposeRemoteDelta",
-            EditorCommand::ResetDelta { .. } => "ResetDelta",
-            EditorCommand::TransformDelta { .. } => "TransformDelta",
+            EditorCommand::ComposeLocalOperations { .. } => "ComposeLocalOperations",
+            EditorCommand::ComposeRemoteOperation { .. } => "ComposeRemoteOperation",
+            EditorCommand::ResetOperations { .. } => "ResetOperations",
+            EditorCommand::TransformOperations { .. } => "TransformOperations",
             EditorCommand::Insert { .. } => "Insert",
             EditorCommand::Delete { .. } => "Delete",
             EditorCommand::Format { .. } => "Format",
@@ -274,8 +267,8 @@ impl std::fmt::Debug for EditorCommand {
             EditorCommand::CanRedo { .. } => "CanRedo",
             EditorCommand::Undo { .. } => "Undo",
             EditorCommand::Redo { .. } => "Redo",
-            EditorCommand::ReadDeltaStr { .. } => "ReadDeltaStr",
-            EditorCommand::ReadDelta { .. } => "ReadDocumentAsDelta",
+            EditorCommand::StringifyOperations { .. } => "StringifyOperations",
+            EditorCommand::ReadOperations { .. } => "ReadOperations",
         };
         f.write_str(s)
     }

frontend/rust-lib/flowy-text-block/src/web_socket.rs → frontend/rust-lib/flowy-document/src/web_socket.rs

@@ -25,7 +25,7 @@ pub(crate) type EditorCommandSender = Sender<EditorCommand>;
 pub(crate) type EditorCommandReceiver = Receiver<EditorCommand>;
 
 #[allow(dead_code)]
-pub(crate) async fn make_block_ws_manager(
+pub(crate) async fn make_document_ws_manager(
     doc_id: String,
     user_id: String,
     edit_cmd_tx: EditorCommandSender,
@@ -113,51 +113,51 @@ struct TextBlockConflictResolver {
 }
 
 impl ConflictResolver<AttributeHashMap> for TextBlockConflictResolver {
-    fn compose_delta(&self, delta: TextOperations) -> BoxResultFuture<OperationsMD5, FlowyError> {
+    fn compose_operations(&self, operations: TextOperations) -> BoxResultFuture<OperationsMD5, FlowyError> {
         let tx = self.edit_cmd_tx.clone();
         Box::pin(async move {
             let (ret, rx) = oneshot::channel();
-            tx.send(EditorCommand::ComposeRemoteDelta {
-                client_delta: delta,
+            tx.send(EditorCommand::ComposeRemoteOperation {
+                client_operations: operations,
                 ret,
             })
             .await
             .map_err(internal_error)?;
-            let md5 = rx.await.map_err(|e| {
-                FlowyError::internal().context(format!("handle EditorCommand::ComposeRemoteDelta failed: {}", e))
-            })??;
+            let md5 = rx
+                .await
+                .map_err(|e| FlowyError::internal().context(format!("Compose operations failed: {}", e)))??;
             Ok(md5)
         })
     }
 
-    fn transform_delta(
+    fn transform_operations(
         &self,
-        delta: TextOperations,
-    ) -> BoxResultFuture<flowy_revision::RichTextTransformDeltas, FlowyError> {
+        operations: TextOperations,
+    ) -> BoxResultFuture<flowy_revision::TextTransformOperations, FlowyError> {
         let tx = self.edit_cmd_tx.clone();
         Box::pin(async move {
-            let (ret, rx) = oneshot::channel::<CollaborateResult<RichTextTransformDeltas>>();
-            tx.send(EditorCommand::TransformDelta { delta, ret })
+            let (ret, rx) = oneshot::channel::<CollaborateResult<TextTransformOperations>>();
+            tx.send(EditorCommand::TransformOperations { operations, ret })
                 .await
                 .map_err(internal_error)?;
-            let transform_delta = rx
+            let transformed_operations = rx
                 .await
-                .map_err(|e| FlowyError::internal().context(format!("TransformDelta failed: {}", e)))??;
-            Ok(transform_delta)
+                .map_err(|e| FlowyError::internal().context(format!("Transform operations failed: {}", e)))??;
+            Ok(transformed_operations)
         })
     }
 
-    fn reset_delta(&self, delta: TextOperations) -> BoxResultFuture<OperationsMD5, FlowyError> {
+    fn reset_operations(&self, operations: TextOperations) -> BoxResultFuture<OperationsMD5, FlowyError> {
         let tx = self.edit_cmd_tx.clone();
         Box::pin(async move {
             let (ret, rx) = oneshot::channel();
             let _ = tx
-                .send(EditorCommand::ResetDelta { delta, ret })
+                .send(EditorCommand::ResetOperations { operations, ret })
                 .await
                 .map_err(internal_error)?;
-            let md5 = rx.await.map_err(|e| {
-                FlowyError::internal().context(format!("handle EditorCommand::OverrideDelta failed: {}", e))
-            })??;
+            let md5 = rx
+                .await
+                .map_err(|e| FlowyError::internal().context(format!("Reset operations failed: {}", e)))??;
             Ok(md5)
         })
     }

frontend/rust-lib/flowy-text-block/tests/document/script.rs → frontend/rust-lib/flowy-document/tests/document/script.rs

@@ -1,7 +1,7 @@
+use flowy_document::editor::DocumentEditor;
+use flowy_document::TEXT_BLOCK_SYNC_INTERVAL_IN_MILLIS;
 use flowy_revision::disk::RevisionState;
 use flowy_test::{helper::ViewTest, FlowySDKTest};
-use flowy_text_block::editor::TextBlockEditor;
-use flowy_text_block::TEXT_BLOCK_SYNC_INTERVAL_IN_MILLIS;
 use lib_ot::{core::Interval, text_delta::TextOperations};
 use std::sync::Arc;
 use tokio::time::{sleep, Duration};
@@ -19,7 +19,7 @@ pub enum EditorScript {
 
 pub struct TextBlockEditorTest {
     pub sdk: FlowySDKTest,
-    pub editor: Arc<TextBlockEditor>,
+    pub editor: Arc<DocumentEditor>,
 }
 
 impl TextBlockEditorTest {
@@ -27,7 +27,11 @@ impl TextBlockEditorTest {
         let sdk = FlowySDKTest::default();
         let _ = sdk.init_user().await;
         let test = ViewTest::new_text_block_view(&sdk).await;
-        let editor = sdk.text_block_manager.open_text_editor(&test.view.id).await.unwrap();
+        let editor = sdk
+            .text_block_manager
+            .open_document_editor(&test.view.id)
+            .await
+            .unwrap();
         Self { sdk, editor }
     }
 
@@ -72,7 +76,7 @@ impl TextBlockEditorTest {
             }
             EditorScript::AssertJson(expected) => {
                 let expected_delta: TextOperations = serde_json::from_str(expected).unwrap();
-                let delta = self.editor.text_block_delta().await.unwrap();
+                let delta = self.editor.document_operations().await.unwrap();
                 if expected_delta != delta {
                     eprintln!("✅ expect: {}", expected,);
                     eprintln!("❌ receive: {}", delta.json_str());

frontend/rust-lib/flowy-text-block/tests/editor/mod.rs → frontend/rust-lib/flowy-document/tests/editor/mod.rs

@@ -5,7 +5,7 @@ mod serde_test;
 mod undo_redo_test;
 
 use derive_more::Display;
-use flowy_sync::client_document::{ClientDocument, InitialDocumentContent};
+use flowy_sync::client_document::{ClientDocument, InitialDocument};
 use lib_ot::{
     core::*,
     text_delta::{BuildInTextAttribute, TextOperations},
@@ -264,7 +264,7 @@ impl TestBuilder {
         }
     }
 
-    pub fn run_scripts<C: InitialDocumentContent>(mut self, scripts: Vec<TestOp>) {
+    pub fn run_scripts<C: InitialDocument>(mut self, scripts: Vec<TestOp>) {
         self.documents = vec![ClientDocument::new::<C>(), ClientDocument::new::<C>()];
         self.primes = vec![None, None];
         self.deltas = vec![None, None];

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

@@ -6,7 +6,7 @@ use crate::{
 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;
@@ -110,7 +110,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
     }

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::text_block::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

@@ -52,7 +52,7 @@ struct FolderConflictResolver {
 }
 
 impl ConflictResolver<EmptyAttributes> for FolderConflictResolver {
-    fn compose_delta(&self, delta: Delta) -> BoxResultFuture<OperationsMD5, FlowyError> {
+    fn compose_operations(&self, delta: Delta) -> BoxResultFuture<OperationsMD5, FlowyError> {
         let folder_pad = self.folder_pad.clone();
         Box::pin(async move {
             let md5 = folder_pad.write().compose_remote_operations(delta)?;
@@ -60,7 +60,7 @@ impl ConflictResolver<EmptyAttributes> for FolderConflictResolver {
         })
     }
 
-    fn transform_delta(&self, delta: Delta) -> BoxResultFuture<TransformDeltas<EmptyAttributes>, FlowyError> {
+    fn transform_operations(&self, delta: Delta) -> BoxResultFuture<TransformOperations<EmptyAttributes>, FlowyError> {
         let folder_pad = self.folder_pad.clone();
         Box::pin(async move {
             let read_guard = folder_pad.read();
@@ -75,14 +75,14 @@ impl ConflictResolver<EmptyAttributes> for FolderConflictResolver {
                 server_prime = Some(s_prime);
             }
             drop(read_guard);
-            Ok(TransformDeltas {
+            Ok(TransformOperations {
                 client_prime,
                 server_prime,
             })
         })
     }
 
-    fn reset_delta(&self, delta: Delta) -> BoxResultFuture<OperationsMD5, FlowyError> {
+    fn reset_operations(&self, delta: Delta) -> BoxResultFuture<OperationsMD5, FlowyError> {
         let folder_pad = self.folder_pad.clone();
         Box::pin(async move {
             let md5 = folder_pad.write().reset_folder(delta)?;

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::text_block::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 {

frontend/rust-lib/flowy-grid/src/services/field/type_options/selection_type_option/select_type_option.rs

@@ -122,7 +122,7 @@ pub trait SelectTypeOptionSharedAction: TypeOptionDataSerializer + Send + Sync {
     fn transform_type_option(&mut self, field_type: &FieldType, _type_option_data: String) {
         match field_type {
             FieldType::Checkbox => {
-                //add Yes and No options if it's not exist.
+                //add Yes and No options if it does not exist.
                 if !self.options().iter().any(|option| option.name == CHECK) {
                     let check_option = SelectOptionPB::with_color(CHECK, SelectOptionColorPB::Green);
                     self.mut_options().push(check_option);

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

@@ -13,7 +13,7 @@ flowy-sync = { path = "../../../shared-lib/flowy-sync"}
 flowy-folder-data-model = { path = "../../../shared-lib/flowy-folder-data-model"}
 flowy-folder = { path = "../flowy-folder" }
 flowy-user = { path = "../flowy-user" }
-flowy-text-block = { path = "../flowy-text-block" }
+flowy-document = { path = "../flowy-document" }
 lazy_static = "1.4.0"
 lib-infra = { path = "../../../shared-lib/lib-infra" }
 protobuf = {version = "2.18.0"}

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

@@ -2,45 +2,45 @@ use crate::{
     configuration::*,
     request::{HttpRequestBuilder, ResponseMiddleware},
 };
+use flowy_document::DocumentCloudService;
 use flowy_error::FlowyError;
-use flowy_sync::entities::text_block::{CreateTextBlockParams, DocumentPB, ResetTextBlockParams, TextBlockIdPB};
-use flowy_text_block::TextEditorCloudService;
+use flowy_sync::entities::text_block::{CreateDocumentParams, DocumentIdPB, DocumentPayloadPB, ResetDocumentParams};
 use http_flowy::response::FlowyResponse;
 use lazy_static::lazy_static;
 use lib_infra::future::FutureResult;
 use std::sync::Arc;
 
-pub struct BlockHttpCloudService {
+pub struct DocumentCloudServiceImpl {
     config: ClientServerConfiguration,
 }
 
-impl BlockHttpCloudService {
+impl DocumentCloudServiceImpl {
     pub fn new(config: ClientServerConfiguration) -> Self {
         Self { config }
     }
 }
 
-impl TextEditorCloudService for BlockHttpCloudService {
-    fn create_text_block(&self, token: &str, params: CreateTextBlockParams) -> FutureResult<(), FlowyError> {
+impl DocumentCloudService for DocumentCloudServiceImpl {
+    fn create_document(&self, token: &str, params: CreateDocumentParams) -> FutureResult<(), FlowyError> {
         let token = token.to_owned();
         let url = self.config.doc_url();
         FutureResult::new(async move { create_document_request(&token, params, &url).await })
     }
 
-    fn read_text_block(&self, token: &str, params: TextBlockIdPB) -> FutureResult<Option<DocumentPB>, FlowyError> {
+    fn fetch_document(&self, token: &str, params: DocumentIdPB) -> FutureResult<Option<DocumentPayloadPB>, FlowyError> {
         let token = token.to_owned();
         let url = self.config.doc_url();
         FutureResult::new(async move { read_document_request(&token, params, &url).await })
     }
 
-    fn update_text_block(&self, token: &str, params: ResetTextBlockParams) -> FutureResult<(), FlowyError> {
+    fn update_document_content(&self, token: &str, params: ResetDocumentParams) -> FutureResult<(), FlowyError> {
         let token = token.to_owned();
         let url = self.config.doc_url();
         FutureResult::new(async move { reset_doc_request(&token, params, &url).await })
     }
 }
 
-pub async fn create_document_request(token: &str, params: CreateTextBlockParams, url: &str) -> Result<(), FlowyError> {
+pub async fn create_document_request(token: &str, params: CreateDocumentParams, url: &str) -> Result<(), FlowyError> {
     let _ = request_builder()
         .post(url)
         .header(HEADER_TOKEN, token)
@@ -52,9 +52,9 @@ pub async fn create_document_request(token: &str, params: CreateTextBlockParams,
 
 pub async fn read_document_request(
     token: &str,
-    params: TextBlockIdPB,
+    params: DocumentIdPB,
     url: &str,
-) -> Result<Option<DocumentPB>, FlowyError> {
+) -> Result<Option<DocumentPayloadPB>, FlowyError> {
     let doc = request_builder()
         .get(url)
         .header(HEADER_TOKEN, token)
@@ -65,7 +65,7 @@ pub async fn read_document_request(
     Ok(doc)
 }
 
-pub async fn reset_doc_request(token: &str, params: ResetTextBlockParams, url: &str) -> Result<(), FlowyError> {
+pub async fn reset_doc_request(token: &str, params: ResetDocumentParams, url: &str) -> Result<(), FlowyError> {
     let _ = request_builder()
         .patch(url)
         .header(HEADER_TOKEN, token)

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::DocumentPB},
+    entities::{folder::FolderInfo, text_block::DocumentPayloadPB},
     errors::CollaborateError,
     server_document::*,
     server_folder::FolderCloudPersistence,
@@ -29,25 +29,25 @@ pub trait RevisionCloudStorage: Send + Sync {
     ) -> BoxResultFuture<(), CollaborateError>;
 }
 
-pub(crate) struct LocalTextBlockCloudPersistence {
+pub(crate) struct LocalDocumentCloudPersistence {
     storage: Arc<dyn RevisionCloudStorage>,
 }
 
-impl Debug for LocalTextBlockCloudPersistence {
+impl Debug for LocalDocumentCloudPersistence {
     fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
         f.write_str("LocalRevisionCloudPersistence")
     }
 }
 
-impl std::default::Default for LocalTextBlockCloudPersistence {
+impl std::default::Default for LocalDocumentCloudPersistence {
     fn default() -> Self {
-        LocalTextBlockCloudPersistence {
+        LocalDocumentCloudPersistence {
             storage: Arc::new(MemoryDocumentCloudStorage::default()),
         }
     }
 }
 
-impl FolderCloudPersistence for LocalTextBlockCloudPersistence {
+impl FolderCloudPersistence for LocalDocumentCloudPersistence {
     fn read_folder(&self, _user_id: &str, folder_id: &str) -> BoxResultFuture<FolderInfo, CollaborateError> {
         let storage = self.storage.clone();
         let folder_id = folder_id.to_owned();
@@ -109,8 +109,8 @@ impl FolderCloudPersistence for LocalTextBlockCloudPersistence {
     }
 }
 
-impl TextBlockCloudPersistence for LocalTextBlockCloudPersistence {
-    fn read_text_block(&self, doc_id: &str) -> BoxResultFuture<DocumentPB, CollaborateError> {
+impl TextBlockCloudPersistence for LocalDocumentCloudPersistence {
+    fn read_text_block(&self, doc_id: &str) -> BoxResultFuture<DocumentPayloadPB, CollaborateError> {
         let storage = self.storage.clone();
         let doc_id = doc_id.to_owned();
         Box::pin(async move {
@@ -126,7 +126,7 @@ impl TextBlockCloudPersistence for LocalTextBlockCloudPersistence {
         &self,
         doc_id: &str,
         repeated_revision: RepeatedRevision,
-    ) -> BoxResultFuture<Option<DocumentPB>, CollaborateError> {
+    ) -> BoxResultFuture<Option<DocumentPayloadPB>, CollaborateError> {
         let doc_id = doc_id.to_owned();
         let storage = self.storage.clone();
         Box::pin(async move {

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

@@ -1,4 +1,4 @@
-use crate::local_server::persistence::LocalTextBlockCloudPersistence;
+use crate::local_server::persistence::LocalDocumentCloudPersistence;
 use async_stream::stream;
 use bytes::Bytes;
 use flowy_error::{internal_error, FlowyError};
@@ -6,7 +6,7 @@ use flowy_folder::event_map::FolderCouldServiceV1;
 use flowy_sync::{
     client_document::default::initial_document_str,
     entities::{
-        text_block::{CreateTextBlockParams, DocumentPB, ResetTextBlockParams, TextBlockIdPB},
+        text_block::{CreateDocumentParams, DocumentIdPB, DocumentPayloadPB, ResetDocumentParams},
         ws_data::{ClientRevisionWSData, ClientRevisionWSDataType},
     },
     errors::CollaborateError,
@@ -39,7 +39,7 @@ impl LocalServer {
         client_ws_sender: mpsc::UnboundedSender<WebSocketRawMessage>,
         client_ws_receiver: broadcast::Sender<WebSocketRawMessage>,
     ) -> Self {
-        let persistence = Arc::new(LocalTextBlockCloudPersistence::default());
+        let persistence = Arc::new(LocalDocumentCloudPersistence::default());
         let doc_manager = Arc::new(ServerDocumentManager::new(persistence.clone()));
         let folder_manager = Arc::new(ServerFolderManager::new(persistence));
         let stop_tx = RwLock::new(None);
@@ -252,6 +252,7 @@ impl RevisionUser for LocalRevisionUser {
     }
 }
 
+use flowy_document::DocumentCloudService;
 use flowy_folder::entities::{
     app::{AppIdPB, CreateAppParams, UpdateAppParams},
     trash::RepeatedTrashIdPB,
@@ -261,7 +262,6 @@ use flowy_folder::entities::{
 use flowy_folder_data_model::revision::{
     gen_app_id, gen_workspace_id, AppRevision, TrashRevision, ViewRevision, WorkspaceRevision,
 };
-use flowy_text_block::TextEditorCloudService;
 use flowy_user::entities::{
     SignInParams, SignInResponse, SignUpParams, SignUpResponse, UpdateUserProfileParams, UserProfilePB,
 };
@@ -414,22 +414,26 @@ impl UserCloudService for LocalServer {
     }
 }
 
-impl TextEditorCloudService for LocalServer {
-    fn create_text_block(&self, _token: &str, _params: CreateTextBlockParams) -> FutureResult<(), FlowyError> {
+impl DocumentCloudService for LocalServer {
+    fn create_document(&self, _token: &str, _params: CreateDocumentParams) -> FutureResult<(), FlowyError> {
         FutureResult::new(async { Ok(()) })
     }
 
-    fn read_text_block(&self, _token: &str, params: TextBlockIdPB) -> FutureResult<Option<DocumentPB>, FlowyError> {
-        let doc = DocumentPB {
-            block_id: params.value,
-            text: initial_document_str(),
+    fn fetch_document(
+        &self,
+        _token: &str,
+        params: DocumentIdPB,
+    ) -> FutureResult<Option<DocumentPayloadPB>, FlowyError> {
+        let doc = DocumentPayloadPB {
+            doc_id: params.value,
+            content: initial_document_str(),
             rev_id: 0,
             base_rev_id: 0,
         };
         FutureResult::new(async { Ok(Some(doc)) })
     }
 
-    fn update_text_block(&self, _token: &str, _params: ResetTextBlockParams) -> FutureResult<(), FlowyError> {
+    fn update_document_content(&self, _token: &str, _params: ResetDocumentParams) -> FutureResult<(), FlowyError> {
         FutureResult::new(async { Ok(()) })
     }
 }

frontend/rust-lib/flowy-revision/src/cache/disk/document_impl.rs

@@ -15,12 +15,12 @@ use flowy_sync::{
 };
 use std::sync::Arc;
 
-pub struct SQLiteTextBlockRevisionPersistence {
+pub struct SQLiteDocumentRevisionPersistence {
     user_id: String,
     pub(crate) pool: Arc<ConnectionPool>,
 }
 
-impl RevisionDiskCache for SQLiteTextBlockRevisionPersistence {
+impl RevisionDiskCache for SQLiteDocumentRevisionPersistence {
     type Error = FlowyError;
 
     fn create_revision_records(&self, revision_records: Vec<RevisionRecord>) -> Result<(), Self::Error> {
@@ -81,7 +81,7 @@ impl RevisionDiskCache for SQLiteTextBlockRevisionPersistence {
     }
 }
 
-impl SQLiteTextBlockRevisionPersistence {
+impl SQLiteDocumentRevisionPersistence {
     pub fn new(user_id: &str, pool: Arc<ConnectionPool>) -> Self {
         Self {
             user_id: user_id.to_owned(),

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

@@ -20,9 +20,9 @@ pub trait ConflictResolver<T>
 where
     T: OperationAttributes + Send + Sync,
 {
-    fn compose_delta(&self, delta: DeltaOperations<T>) -> BoxResultFuture<OperationsMD5, FlowyError>;
-    fn transform_delta(&self, delta: DeltaOperations<T>) -> BoxResultFuture<TransformDeltas<T>, FlowyError>;
-    fn reset_delta(&self, delta: DeltaOperations<T>) -> BoxResultFuture<OperationsMD5, FlowyError>;
+    fn compose_operations(&self, delta: DeltaOperations<T>) -> BoxResultFuture<OperationsMD5, FlowyError>;
+    fn transform_operations(&self, delta: DeltaOperations<T>) -> BoxResultFuture<TransformOperations<T>, FlowyError>;
+    fn reset_operations(&self, delta: DeltaOperations<T>) -> BoxResultFuture<OperationsMD5, FlowyError>;
 }
 
 pub trait ConflictRevisionSink: Send + Sync + 'static {
@@ -105,23 +105,23 @@ where
 
         let new_delta = make_operations_from_revisions(revisions.clone())?;
 
-        let TransformDeltas {
+        let TransformOperations {
             client_prime,
             server_prime,
-        } = self.resolver.transform_delta(new_delta).await?;
+        } = self.resolver.transform_operations(new_delta).await?;
 
         match server_prime {
             None => {
                 // The server_prime is None means the client local revisions conflict with the
                 // // server, and it needs to override the client delta.
-                let md5 = self.resolver.reset_delta(client_prime).await?;
+                let md5 = self.resolver.reset_operations(client_prime).await?;
                 let repeated_revision = RepeatedRevision::new(revisions);
                 assert_eq!(repeated_revision.last().unwrap().md5, md5);
                 let _ = self.rev_manager.reset_object(repeated_revision).await?;
                 Ok(None)
             }
             Some(server_prime) => {
-                let md5 = self.resolver.compose_delta(client_prime.clone()).await?;
+                let md5 = self.resolver.compose_operations(client_prime.clone()).await?;
                 for revision in &revisions {
                     let _ = self.rev_manager.add_remote_revision(revision).await?;
                 }
@@ -175,9 +175,9 @@ where
     }
 }
 
-pub type RichTextTransformDeltas = TransformDeltas<AttributeHashMap>;
+pub type TextTransformOperations = TransformOperations<AttributeHashMap>;
 
-pub struct TransformDeltas<T>
+pub struct TransformOperations<T>
 where
     T: OperationAttributes,
 {

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

@@ -1,5 +1,5 @@
 use crate::cache::{
-    disk::{RevisionChangeset, RevisionDiskCache, SQLiteTextBlockRevisionPersistence},
+    disk::{RevisionChangeset, RevisionDiskCache, SQLiteDocumentRevisionPersistence},
     memory::RevisionMemoryCacheDelegate,
 };
 use crate::disk::{RevisionRecord, RevisionState, SQLiteGridBlockRevisionPersistence};
@@ -228,7 +228,7 @@ pub fn mk_text_block_revision_disk_cache(
     user_id: &str,
     pool: Arc<ConnectionPool>,
 ) -> Arc<dyn RevisionDiskCache<Error = FlowyError>> {
-    Arc::new(SQLiteTextBlockRevisionPersistence::new(user_id, pool))
+    Arc::new(SQLiteDocumentRevisionPersistence::new(user_id, pool))
 }
 
 pub fn mk_grid_block_revision_disk_cache(

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

@@ -14,7 +14,7 @@ flowy-folder = { path = "../flowy-folder", default-features = false }
 flowy-grid = { path = "../flowy-grid", default-features = false }
 flowy-grid-data-model = { path = "../../../shared-lib/flowy-grid-data-model" }
 flowy-database = { path = "../flowy-database" }
-flowy-text-block = { path = "../flowy-text-block", default-features = false }
+flowy-document = { path = "../flowy-document", default-features = false }
 flowy-revision = { path = "../flowy-revision" }
 
 tracing = { version = "0.1" }
@@ -38,8 +38,8 @@ tokio = { version = "1", features = ["full"] }
 futures-util = "0.3.15"
 
 [features]
-http_sync = ["flowy-folder/cloud_sync", "flowy-text-block/cloud_sync"]
-native_sync = ["flowy-folder/cloud_sync", "flowy-text-block/cloud_sync"]
+http_sync = ["flowy-folder/cloud_sync", "flowy-document/cloud_sync"]
+native_sync = ["flowy-folder/cloud_sync", "flowy-document/cloud_sync"]
 use_bunyan = ["lib-log/use_bunyan"]
 dart = [
     "flowy-user/dart",
@@ -47,6 +47,6 @@ dart = [
     "flowy-folder/dart",
     "flowy-sync/dart",
     "flowy-grid/dart",
-    "flowy-text-block/dart",
+    "flowy-document/dart",
 ]
 openssl_vendored = ["flowy-database/openssl_vendored"]

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

@@ -1,37 +1,37 @@
 use bytes::Bytes;
 use flowy_database::ConnectionPool;
+use flowy_document::{
+    errors::{internal_error, FlowyError},
+    DocumentCloudService, DocumentEditorManager, DocumentUser,
+};
 use flowy_net::ClientServerConfiguration;
 use flowy_net::{
-    http_server::document::BlockHttpCloudService, local_server::LocalServer, ws::connection::FlowyWebSocketConnect,
+    http_server::document::DocumentCloudServiceImpl, local_server::LocalServer, ws::connection::FlowyWebSocketConnect,
 };
 use flowy_revision::{RevisionWebSocket, WSStateReceiver};
 use flowy_sync::entities::ws_data::ClientRevisionWSData;
-use flowy_text_block::{
-    errors::{internal_error, FlowyError},
-    TextEditorCloudService, TextEditorManager, TextEditorUser,
-};
 use flowy_user::services::UserSession;
 use futures_core::future::BoxFuture;
 use lib_infra::future::BoxResultFuture;
 use lib_ws::{WSChannel, WSMessageReceiver, WebSocketRawMessage};
 use std::{convert::TryInto, path::Path, sync::Arc};
 
-pub struct TextBlockDepsResolver();
-impl TextBlockDepsResolver {
+pub struct DocumentDepsResolver();
+impl DocumentDepsResolver {
     pub fn resolve(
         local_server: Option<Arc<LocalServer>>,
         ws_conn: Arc<FlowyWebSocketConnect>,
         user_session: Arc<UserSession>,
         server_config: &ClientServerConfiguration,
-    ) -> Arc<TextEditorManager> {
+    ) -> Arc<DocumentEditorManager> {
         let user = Arc::new(BlockUserImpl(user_session));
-        let rev_web_socket = Arc::new(TextBlockWebSocket(ws_conn.clone()));
-        let cloud_service: Arc<dyn TextEditorCloudService> = match local_server {
-            None => Arc::new(BlockHttpCloudService::new(server_config.clone())),
+        let rev_web_socket = Arc::new(DocumentRevisionWebSocket(ws_conn.clone()));
+        let cloud_service: Arc<dyn DocumentCloudService> = match local_server {
+            None => Arc::new(DocumentCloudServiceImpl::new(server_config.clone())),
             Some(local_server) => local_server,
         };
 
-        let manager = Arc::new(TextEditorManager::new(cloud_service, user, rev_web_socket));
+        let manager = Arc::new(DocumentEditorManager::new(cloud_service, user, rev_web_socket));
         let receiver = Arc::new(DocumentWSMessageReceiverImpl(manager.clone()));
         ws_conn.add_ws_message_receiver(receiver).unwrap();
 
@@ -40,7 +40,7 @@ impl TextBlockDepsResolver {
 }
 
 struct BlockUserImpl(Arc<UserSession>);
-impl TextEditorUser for BlockUserImpl {
+impl DocumentUser for BlockUserImpl {
     fn user_dir(&self) -> Result<String, FlowyError> {
         let dir = self.0.user_dir().map_err(|e| FlowyError::unauthorized().context(e))?;
 
@@ -64,8 +64,8 @@ impl TextEditorUser for BlockUserImpl {
     }
 }
 
-struct TextBlockWebSocket(Arc<FlowyWebSocketConnect>);
-impl RevisionWebSocket for TextBlockWebSocket {
+struct DocumentRevisionWebSocket(Arc<FlowyWebSocketConnect>);
+impl RevisionWebSocket for DocumentRevisionWebSocket {
     fn send(&self, data: ClientRevisionWSData) -> BoxResultFuture<(), FlowyError> {
         let bytes: Bytes = data.try_into().unwrap();
         let msg = WebSocketRawMessage {
@@ -90,7 +90,7 @@ impl RevisionWebSocket for TextBlockWebSocket {
     }
 }
 
-struct DocumentWSMessageReceiverImpl(Arc<TextEditorManager>);
+struct DocumentWSMessageReceiverImpl(Arc<DocumentEditorManager>);
 impl WSMessageReceiver for DocumentWSMessageReceiverImpl {
     fn source(&self) -> WSChannel {
         WSChannel::Document

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

@@ -1,5 +1,6 @@
 use bytes::Bytes;
 use flowy_database::ConnectionPool;
+use flowy_document::DocumentEditorManager;
 use flowy_folder::entities::{ViewDataTypePB, ViewLayoutTypePB};
 use flowy_folder::manager::{ViewDataProcessor, ViewDataProcessorMap};
 use flowy_folder::{
@@ -19,7 +20,6 @@ use flowy_revision::{RevisionWebSocket, WSStateReceiver};
 use flowy_sync::client_document::default::initial_document_str;
 use flowy_sync::entities::revision::{RepeatedRevision, Revision};
 use flowy_sync::entities::ws_data::ClientRevisionWSData;
-use flowy_text_block::TextEditorManager;
 use flowy_user::services::UserSession;
 use futures_core::future::BoxFuture;
 use lib_infra::future::{BoxResultFuture, FutureResult};
@@ -35,12 +35,12 @@ impl FolderDepsResolver {
         user_session: Arc<UserSession>,
         server_config: &ClientServerConfiguration,
         ws_conn: &Arc<FlowyWebSocketConnect>,
-        text_block_manager: &Arc<TextEditorManager>,
+        text_block_manager: &Arc<DocumentEditorManager>,
         grid_manager: &Arc<GridManager>,
     ) -> Arc<FolderManager> {
         let user: Arc<dyn WorkspaceUser> = Arc::new(WorkspaceUserImpl(user_session.clone()));
         let database: Arc<dyn WorkspaceDatabase> = Arc::new(WorkspaceDatabaseImpl(user_session));
-        let web_socket = Arc::new(FolderWebSocket(ws_conn.clone()));
+        let web_socket = Arc::new(FolderRevisionWebSocket(ws_conn.clone()));
         let cloud_service: Arc<dyn FolderCouldServiceV1> = match local_server {
             None => Arc::new(FolderHttpCloudService::new(server_config.clone())),
             Some(local_server) => local_server,
@@ -64,12 +64,12 @@ impl FolderDepsResolver {
 }
 
 fn make_view_data_processor(
-    text_block_manager: Arc<TextEditorManager>,
+    text_block_manager: Arc<DocumentEditorManager>,
     grid_manager: Arc<GridManager>,
 ) -> ViewDataProcessorMap {
     let mut map: HashMap<ViewDataTypePB, Arc<dyn ViewDataProcessor + Send + Sync>> = HashMap::new();
 
-    let block_data_impl = TextBlockViewDataProcessor(text_block_manager);
+    let block_data_impl = DocumentViewDataProcessor(text_block_manager);
     map.insert(block_data_impl.data_type(), Arc::new(block_data_impl));
 
     let grid_data_impl = GridViewDataProcessor(grid_manager);
@@ -96,8 +96,8 @@ impl WorkspaceUser for WorkspaceUserImpl {
     }
 }
 
-struct FolderWebSocket(Arc<FlowyWebSocketConnect>);
-impl RevisionWebSocket for FolderWebSocket {
+struct FolderRevisionWebSocket(Arc<FlowyWebSocketConnect>);
+impl RevisionWebSocket for FolderRevisionWebSocket {
     fn send(&self, data: ClientRevisionWSData) -> BoxResultFuture<(), FlowyError> {
         let bytes: Bytes = data.try_into().unwrap();
         let msg = WebSocketRawMessage {
@@ -136,8 +136,8 @@ impl WSMessageReceiver for FolderWSMessageReceiverImpl {
     }
 }
 
-struct TextBlockViewDataProcessor(Arc<TextEditorManager>);
-impl ViewDataProcessor for TextBlockViewDataProcessor {
+struct DocumentViewDataProcessor(Arc<DocumentEditorManager>);
+impl ViewDataProcessor for DocumentViewDataProcessor {
     fn initialize(&self) -> FutureResult<(), FlowyError> {
         let manager = self.0.clone();
         FutureResult::new(async move { manager.init() })
@@ -156,7 +156,7 @@ impl ViewDataProcessor for TextBlockViewDataProcessor {
         let view_id = view_id.to_string();
         let manager = self.0.clone();
         FutureResult::new(async move {
-            let _ = manager.create_text_block(view_id, repeated_revision).await?;
+            let _ = manager.create_document(view_id, repeated_revision).await?;
             Ok(())
         })
     }
@@ -174,8 +174,8 @@ impl ViewDataProcessor for TextBlockViewDataProcessor {
         let view_id = view_id.to_string();
         let manager = self.0.clone();
         FutureResult::new(async move {
-            let editor = manager.open_text_editor(view_id).await?;
-            let delta_bytes = Bytes::from(editor.delta_str().await?);
+            let editor = manager.open_document_editor(view_id).await?;
+            let delta_bytes = Bytes::from(editor.get_operation_str().await?);
             Ok(delta_bytes)
         })
     }
@@ -195,7 +195,7 @@ impl ViewDataProcessor for TextBlockViewDataProcessor {
             let delta_data = Bytes::from(view_data);
             let repeated_revision: RepeatedRevision =
                 Revision::initial_revision(&user_id, &view_id, delta_data.clone()).into();
-            let _ = manager.create_text_block(view_id, repeated_revision).await?;
+            let _ = manager.create_document(view_id, repeated_revision).await?;
             Ok(delta_data)
         })
     }

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

@@ -18,7 +18,7 @@ pub struct GridDepsResolver();
 impl GridDepsResolver {
     pub async fn resolve(ws_conn: Arc<FlowyWebSocketConnect>, user_session: Arc<UserSession>) -> Arc<GridManager> {
         let user = Arc::new(GridUserImpl(user_session.clone()));
-        let rev_web_socket = Arc::new(GridWebSocket(ws_conn));
+        let rev_web_socket = Arc::new(GridRevisionWebSocket(ws_conn));
         let grid_manager = Arc::new(GridManager::new(
             user.clone(),
             rev_web_socket,
@@ -58,8 +58,8 @@ impl GridUser for GridUserImpl {
     }
 }
 
-struct GridWebSocket(Arc<FlowyWebSocketConnect>);
-impl RevisionWebSocket for GridWebSocket {
+struct GridRevisionWebSocket(Arc<FlowyWebSocketConnect>);
+impl RevisionWebSocket for GridRevisionWebSocket {
     fn send(&self, data: ClientRevisionWSData) -> BoxResultFuture<(), FlowyError> {
         let bytes: Bytes = data.try_into().unwrap();
         let msg = WebSocketRawMessage {

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

@@ -1,10 +1,10 @@
+mod document_deps;
 mod folder_deps;
 mod grid_deps;
-mod text_block_deps;
 mod user_deps;
 mod util;
 
+pub use document_deps::*;
 pub use folder_deps::*;
 pub use grid_deps::*;
-pub use text_block_deps::*;
 pub use user_deps::*;

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

@@ -3,6 +3,7 @@ pub mod module;
 pub use flowy_net::get_client_server_configuration;
 
 use crate::deps_resolve::*;
+use flowy_document::DocumentEditorManager;
 use flowy_folder::{errors::FlowyError, manager::FolderManager};
 use flowy_grid::manager::GridManager;
 use flowy_net::ClientServerConfiguration;
@@ -11,7 +12,6 @@ use flowy_net::{
     local_server::LocalServer,
     ws::connection::{listen_on_websocket, FlowyWebSocketConnect},
 };
-use flowy_text_block::TextEditorManager;
 use flowy_user::services::{notifier::UserStatus, UserSession, UserSessionConfig};
 use lib_dispatch::prelude::*;
 use lib_dispatch::runtime::tokio_default_runtime;
@@ -67,7 +67,7 @@ fn crate_log_filter(level: String) -> String {
     filters.push(format!("flowy_sdk={}", level));
     filters.push(format!("flowy_folder={}", level));
     filters.push(format!("flowy_user={}", level));
-    filters.push(format!("flowy_text_block={}", level));
+    filters.push(format!("flowy_document={}", level));
     filters.push(format!("flowy_grid={}", level));
     filters.push(format!("flowy_collaboration={}", "info"));
     filters.push(format!("dart_notify={}", level));
@@ -89,7 +89,7 @@ pub struct FlowySDK {
     #[allow(dead_code)]
     config: FlowySDKConfig,
     pub user_session: Arc<UserSession>,
-    pub text_block_manager: Arc<TextEditorManager>,
+    pub text_block_manager: Arc<DocumentEditorManager>,
     pub folder_manager: Arc<FolderManager>,
     pub grid_manager: Arc<GridManager>,
     pub dispatcher: Arc<EventDispatcher>,
@@ -106,7 +106,7 @@ impl FlowySDK {
         let (local_server, ws_conn) = mk_local_server(&config.server_config);
         let (user_session, text_block_manager, folder_manager, local_server, grid_manager) = runtime.block_on(async {
             let user_session = mk_user_session(&config, &local_server, &config.server_config);
-            let text_block_manager = TextBlockDepsResolver::resolve(
+            let text_block_manager = DocumentDepsResolver::resolve(
                 local_server.clone(),
                 ws_conn.clone(),
                 user_session.clone(),

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

@@ -1,7 +1,7 @@
+use flowy_document::DocumentEditorManager;
 use flowy_folder::manager::FolderManager;
 use flowy_grid::manager::GridManager;
 use flowy_net::ws::connection::FlowyWebSocketConnect;
-use flowy_text_block::TextEditorManager;
 use flowy_user::services::UserSession;
 use lib_dispatch::prelude::Module;
 use std::sync::Arc;
@@ -11,7 +11,7 @@ pub fn mk_modules(
     folder_manager: &Arc<FolderManager>,
     grid_manager: &Arc<GridManager>,
     user_session: &Arc<UserSession>,
-    text_block_manager: &Arc<TextEditorManager>,
+    text_block_manager: &Arc<DocumentEditorManager>,
 ) -> 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<TextEditorManager>) -> Module {
-    flowy_text_block::event_map::create(text_block_manager)
+fn mk_text_block_module(text_block_manager: Arc<DocumentEditorManager>) -> Module {
+    flowy_document::event_map::create(text_block_manager)
 }

frontend/rust-lib/flowy-text-block/src/event_handler.rs

@@ -1,43 +0,0 @@
-use crate::entities::{EditParams, EditPayloadPB, ExportDataPB, ExportParams, ExportPayloadPB, TextBlockPB};
-use crate::TextEditorManager;
-use flowy_error::FlowyError;
-use flowy_sync::entities::text_block::TextBlockIdPB;
-use lib_dispatch::prelude::{data_result, AppData, Data, DataResult};
-use std::convert::TryInto;
-use std::sync::Arc;
-
-pub(crate) async fn get_text_block_handler(
-    data: Data<TextBlockIdPB>,
-    manager: AppData<Arc<TextEditorManager>>,
-) -> DataResult<TextBlockPB, FlowyError> {
-    let text_block_id: TextBlockIdPB = data.into_inner();
-    let editor = manager.open_text_editor(&text_block_id).await?;
-    let delta_str = editor.delta_str().await?;
-    data_result(TextBlockPB {
-        text_block_id: text_block_id.into(),
-        snapshot: delta_str,
-    })
-}
-
-pub(crate) async fn apply_edit_handler(
-    data: Data<EditPayloadPB>,
-    manager: AppData<Arc<TextEditorManager>>,
-) -> Result<(), FlowyError> {
-    let params: EditParams = data.into_inner().try_into()?;
-    let _ = manager.apply_edit(params).await?;
-    Ok(())
-}
-
-#[tracing::instrument(level = "debug", skip(data, manager), err)]
-pub(crate) async fn export_handler(
-    data: Data<ExportPayloadPB>,
-    manager: AppData<Arc<TextEditorManager>>,
-) -> DataResult<ExportDataPB, FlowyError> {
-    let params: ExportParams = data.into_inner().try_into()?;
-    let editor = manager.open_text_editor(&params.view_id).await?;
-    let delta_json = editor.delta_str().await?;
-    data_result(ExportDataPB {
-        data: delta_json,
-        export_type: params.export_type,
-    })
-}

frontend/rust-lib/flowy-text-block/src/lib.rs

@@ -1,27 +0,0 @@
-pub mod editor;
-mod entities;
-mod event_handler;
-pub mod event_map;
-pub mod manager;
-mod queue;
-mod web_socket;
-
-pub mod protobuf;
-pub use manager::*;
-pub mod errors {
-    pub use flowy_error::{internal_error, ErrorCode, FlowyError};
-}
-
-pub const TEXT_BLOCK_SYNC_INTERVAL_IN_MILLIS: u64 = 1000;
-
-use crate::errors::FlowyError;
-use flowy_sync::entities::text_block::{CreateTextBlockParams, DocumentPB, ResetTextBlockParams, TextBlockIdPB};
-use lib_infra::future::FutureResult;
-
-pub trait TextEditorCloudService: Send + Sync {
-    fn create_text_block(&self, token: &str, params: CreateTextBlockParams) -> FutureResult<(), FlowyError>;
-
-    fn read_text_block(&self, token: &str, params: TextBlockIdPB) -> FutureResult<Option<DocumentPB>, FlowyError>;
-
-    fn update_text_block(&self, token: &str, params: ResetTextBlockParams) -> FutureResult<(), FlowyError>;
-}

shared-lib/flowy-sync/src/client_document/document_pad.rs

@@ -10,19 +10,19 @@ use bytes::Bytes;
 use lib_ot::{core::*, text_delta::TextOperations};
 use tokio::sync::mpsc;
 
-pub trait InitialDocumentContent {
+pub trait InitialDocument {
     fn json_str() -> String;
 }
 
 pub struct EmptyDoc();
-impl InitialDocumentContent for EmptyDoc {
+impl InitialDocument for EmptyDoc {
     fn json_str() -> String {
         TextOperations::default().json_str()
     }
 }
 
 pub struct NewlineDoc();
-impl InitialDocumentContent for NewlineDoc {
+impl InitialDocument for NewlineDoc {
     fn json_str() -> String {
         initial_document_str()
     }
@@ -37,7 +37,7 @@ pub struct ClientDocument {
 }
 
 impl ClientDocument {
-    pub fn new<C: InitialDocumentContent>() -> Self {
+    pub fn new<C: InitialDocument>() -> Self {
         let content = C::json_str();
         Self::from_json(&content).unwrap()
     }

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

@@ -6,21 +6,21 @@ use flowy_derive::ProtoBuf;
 use lib_ot::{errors::OTError, text_delta::TextOperations};
 
 #[derive(ProtoBuf, Default, Debug, Clone)]
-pub struct CreateTextBlockParams {
+pub struct CreateDocumentParams {
     #[pb(index = 1)]
-    pub id: String,
+    pub doc_id: String,
 
     #[pb(index = 2)]
     pub revisions: RepeatedRevision,
 }
 
 #[derive(ProtoBuf, Default, Debug, Clone, Eq, PartialEq)]
-pub struct DocumentPB {
+pub struct DocumentPayloadPB {
     #[pb(index = 1)]
-    pub block_id: String,
+    pub doc_id: String,
 
     #[pb(index = 2)]
-    pub text: String,
+    pub content: String,
 
     #[pb(index = 3)]
     pub rev_id: i64,
@@ -29,14 +29,14 @@ pub struct DocumentPB {
     pub base_rev_id: i64,
 }
 
-impl DocumentPB {
+impl DocumentPayloadPB {
     pub fn delta(&self) -> Result<TextOperations, OTError> {
-        let delta = TextOperations::from_bytes(&self.text)?;
+        let delta = TextOperations::from_bytes(&self.content)?;
         Ok(delta)
     }
 }
 
-impl std::convert::TryFrom<Revision> for DocumentPB {
+impl std::convert::TryFrom<Revision> for DocumentPayloadPB {
     type Error = CollaborateError;
 
     fn try_from(revision: Revision) -> Result<Self, Self::Error> {
@@ -48,9 +48,9 @@ impl std::convert::TryFrom<Revision> for DocumentPB {
         let delta = TextOperations::from_bytes(&revision.bytes)?;
         let doc_json = delta.json_str();
 
-        Ok(DocumentPB {
-            block_id: revision.object_id,
-            text: doc_json,
+        Ok(DocumentPayloadPB {
+            doc_id: revision.object_id,
+            content: doc_json,
             rev_id: revision.rev_id,
             base_rev_id: revision.base_rev_id,
         })
@@ -58,21 +58,21 @@ impl std::convert::TryFrom<Revision> for DocumentPB {
 }
 
 #[derive(ProtoBuf, Default, Debug, Clone)]
-pub struct ResetTextBlockParams {
+pub struct ResetDocumentParams {
     #[pb(index = 1)]
-    pub block_id: String,
+    pub doc_id: String,
 
     #[pb(index = 2)]
     pub revisions: RepeatedRevision,
 }
 
 #[derive(ProtoBuf, Default, Debug, Clone)]
-pub struct TextBlockDeltaPB {
+pub struct DocumentOperationsPB {
     #[pb(index = 1)]
-    pub text_block_id: String,
+    pub doc_id: String,
 
     #[pb(index = 2)]
-    pub delta_str: String,
+    pub operations_str: String,
 }
 
 #[derive(ProtoBuf, Default, Debug, Clone)]
@@ -88,30 +88,30 @@ pub struct NewDocUserPB {
 }
 
 #[derive(ProtoBuf, Default, Debug, Clone)]
-pub struct TextBlockIdPB {
+pub struct DocumentIdPB {
     #[pb(index = 1)]
     pub value: String,
 }
-impl AsRef<str> for TextBlockIdPB {
+impl AsRef<str> for DocumentIdPB {
     fn as_ref(&self) -> &str {
         &self.value
     }
 }
 
-impl std::convert::From<String> for TextBlockIdPB {
+impl std::convert::From<String> for DocumentIdPB {
     fn from(value: String) -> Self {
-        TextBlockIdPB { value }
+        DocumentIdPB { value }
     }
 }
 
-impl std::convert::From<TextBlockIdPB> for String {
-    fn from(block_id: TextBlockIdPB) -> Self {
+impl std::convert::From<DocumentIdPB> for String {
+    fn from(block_id: DocumentIdPB) -> Self {
         block_id.value
     }
 }
 
-impl std::convert::From<&String> for TextBlockIdPB {
+impl std::convert::From<&String> for DocumentIdPB {
     fn from(s: &String) -> Self {
-        TextBlockIdPB { value: s.to_owned() }
+        DocumentIdPB { value: s.to_owned() }
     }
 }

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::DocumentPB, ws_data::ServerRevisionWSDataBuilder},
+    entities::{text_block::DocumentPayloadPB, ws_data::ServerRevisionWSDataBuilder},
     errors::{internal_error, CollaborateError, CollaborateResult},
     protobuf::ClientRevisionWSData,
     server_document::document_pad::ServerDocument,
@@ -20,13 +20,13 @@ use tokio::{
 };
 
 pub trait TextBlockCloudPersistence: Send + Sync + Debug {
-    fn read_text_block(&self, doc_id: &str) -> BoxResultFuture<DocumentPB, CollaborateError>;
+    fn read_text_block(&self, doc_id: &str) -> BoxResultFuture<DocumentPayloadPB, CollaborateError>;
 
     fn create_text_block(
         &self,
         doc_id: &str,
         repeated_revision: RepeatedRevision,
-    ) -> BoxResultFuture<Option<DocumentPB>, CollaborateError>;
+    ) -> BoxResultFuture<Option<DocumentPayloadPB>, CollaborateError>;
 
     fn read_text_block_revisions(
         &self,
@@ -184,7 +184,10 @@ impl ServerDocumentManager {
     }
 
     #[tracing::instrument(level = "debug", skip(self, doc), err)]
-    async fn create_document_handler(&self, doc: DocumentPB) -> Result<Arc<OpenDocumentHandler>, CollaborateError> {
+    async fn create_document_handler(
+        &self,
+        doc: DocumentPayloadPB,
+    ) -> Result<Arc<OpenDocumentHandler>, CollaborateError> {
         let persistence = self.persistence.clone();
         let handle = spawn_blocking(|| OpenDocumentHandler::new(doc, persistence))
             .await
@@ -208,16 +211,16 @@ struct OpenDocumentHandler {
 }
 
 impl OpenDocumentHandler {
-    fn new(doc: DocumentPB, persistence: Arc<dyn TextBlockCloudPersistence>) -> Result<Self, CollaborateError> {
-        let doc_id = doc.block_id.clone();
+    fn new(doc: DocumentPayloadPB, persistence: Arc<dyn TextBlockCloudPersistence>) -> Result<Self, CollaborateError> {
+        let doc_id = doc.doc_id.clone();
         let (sender, receiver) = mpsc::channel(1000);
         let users = DashMap::new();
 
-        let operations = TextOperations::from_bytes(&doc.text)?;
+        let operations = TextOperations::from_bytes(&doc.content)?;
         let sync_object = ServerDocument::from_operations(&doc_id, operations);
         let synchronizer = Arc::new(DocumentRevisionSynchronizer::new(doc.rev_id, sync_object, persistence));
 
-        let queue = DocumentCommandRunner::new(&doc.block_id, receiver, synchronizer);
+        let queue = DocumentCommandRunner::new(&doc.doc_id, receiver, synchronizer);
         tokio::task::spawn(queue.run());
         Ok(Self { doc_id, sender, users })
     }

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

@@ -1,5 +1,5 @@
 use crate::synchronizer::RevisionOperations;
-use crate::{client_document::InitialDocumentContent, errors::CollaborateError, synchronizer::RevisionSyncObject};
+use crate::{client_document::InitialDocument, errors::CollaborateError, synchronizer::RevisionSyncObject};
 use lib_ot::{core::*, text_delta::TextOperations};
 
 pub struct ServerDocument {
@@ -9,7 +9,7 @@ pub struct ServerDocument {
 
 impl ServerDocument {
     #[allow(dead_code)]
-    pub fn new<C: InitialDocumentContent>(doc_id: &str) -> Self {
+    pub fn new<C: InitialDocument>(doc_id: &str) -> Self {
         let operations = TextOperations::from_json(&C::json_str()).unwrap();
         Self::from_operations(doc_id, operations)
     }

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

@@ -3,7 +3,7 @@ use crate::{
     entities::{
         folder::FolderInfo,
         revision::{RepeatedRevision, Revision},
-        text_block::DocumentPB,
+        text_block::DocumentPayloadPB,
     },
     errors::{CollaborateError, CollaborateResult},
 };
@@ -149,7 +149,7 @@ pub fn make_folder_from_revisions_pb(
 pub fn make_document_from_revision_pbs(
     doc_id: &str,
     revisions: RepeatedRevision,
-) -> Result<Option<DocumentPB>, CollaborateError> {
+) -> Result<Option<DocumentPayloadPB>, CollaborateError> {
     let revisions = revisions.into_inner();
     if revisions.is_empty() {
         return Ok(None);
@@ -172,9 +172,9 @@ pub fn make_document_from_revision_pbs(
 
     let text = delta.json_str();
 
-    Ok(Some(DocumentPB {
-        block_id: doc_id.to_owned(),
-        text,
+    Ok(Some(DocumentPayloadPB {
+        doc_id: doc_id.to_owned(),
+        content: text,
         rev_id,
         base_rev_id,
     }))