Merge branch 'AppFlowy-IO:main' into documentation/flowy_editor

frontend/app_flowy/packages/flowy_editor/README.md

@@ -11,19 +11,31 @@ and the Flutter guide for
 [developing packages and plugins](https://flutter.dev/developing-packages). 
 -->
 
-一个易于扩展，测试覆盖的 flutter 富文本编辑组件
+<center><big><b>FlowyEditor</b></big></center>
+
+<p align="center">An easily extensible, test-covered rich text editing component for Flutter</p>
+
+![](documentation/images/example.png)
 
 ## Features
 
-* 易于扩展的
+* Extensible
+    * Support for extending different styles of views.
     * 支持扩展不同样式的视图
-    * 支持定制快捷键解析
-    * 支持扩展toolbar/popup list样式(WIP)
+    * Support extending custom shortcut key parsing
+    * 支持扩展自定义快捷键解析
+    * Support extending toolbar/popup list(WIP)
+    * 支持扩展toolbar/popup list(WIP)
     * ...
-* 协同结构 ready
-    * 
-* 质量保证的
-    * 由于可扩展的结构，以及随着功能的增多，我们鼓励每个提交的文件或者代码段，都可以在test下增加对应的测试用例代码，尽可能得保证提交者不需要担心自己的代码影响了已有的逻辑。
+* Collaboration Ready
+    * All changes to the document are based on **operation**. Theoretically, collaborative editing will be supported in the future.
+    * 所有对文档的修改都是基于operation。理论上未来会支持协同编辑。
+* Good stability guarantees
+    * Current code coverage >= 60%, we will still continue to add more test cases.
+
+> 由于可扩展的结构，以及随着功能的增多，我们鼓励每个提交的文件或者代码段，都可以在test下增加对应的测试用例代码，尽可能得保证提交者不需要担心自己的代码影响了已有的逻辑。
+
+> Due to the extensible structure and the increase in functionality, we encourage each commit to add test case code under test to ensure that the committer does not have to worry about their code affecting the existing logic as much as possible.
 
 
 ## Getting started
@@ -35,7 +47,7 @@ flutter pub get
 
 ## Usage
 
-Empty document
+Creates editor with empty document
 ```dart
 final editorState = EditorState.empty();
 final editor = FlowyEditor(
@@ -45,7 +57,7 @@ final editor = FlowyEditor(
 );
 ```
 
-从JSON文件中读取
+Creates editor from JSON file
 ```dart
 final json = ...;
 final editorState = EditorState(StateTree.fromJson(data));
@@ -71,16 +83,10 @@ flutter run
     * BUIS - 展示如何通过快捷键对文字进行加粗/下划线/斜体/加粗
     * 粘贴HTML - 展示如何通过快捷键处理粘贴的样式
 
-## Documentation
-* 术语表
+## Glossary
 
 
 
-## Additional information
 
-目前正在完善更多的文档信息
-* Selection
-* 
-
-我们还有很多工作需要继续完成，链接到contributing.md
-Project checker link.
+## Contributing
+Contributions are what make the open source community such an amazing place to be learn, inspire, and create. Any contributions you make are greatly appreciated. Please look at [CONTRIBUTING.md](documentation/contributing.md) for details.

frontend/app_flowy/packages/flowy_editor/example/assets/example.json

@@ -37,7 +37,15 @@
         "type": "text",
         "delta": [
           {
-            "insert": "We are still developing more features. Please give us a star if the "
+            "insert": "Since we are a community-driven open source editor, we very welcome and appreciate every pull request submissions from everyone.😄😄😄"
+          }
+        ]
+      },
+      {
+        "type": "text",
+        "delta": [
+          {
+            "insert": "To be honest, we are still in the alpha stage, there are still many functions that need to be completed. And we are still developing more features. Please give us a star if the "
           },
           {
             "insert": "FlowyEditor",
@@ -46,7 +54,7 @@
             }
           },
           {
-            "insert": " helps you."
+            "insert": " helps you. 😊😊😊"
           }
         ]
       },

frontend/rust-lib/Cargo.lock

@@ -1039,6 +1039,7 @@ dependencies = [
  "lib-ot",
  "lib-ws",
  "serde",
+ "serde_json",
  "strum",
  "strum_macros",
  "tokio",

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

@@ -5,15 +5,18 @@ use crate::{
 };
 use flowy_database::kv::KV;
 use flowy_error::{FlowyError, FlowyResult};
-
-use flowy_folder_data_model::revision::{AppRevision, ViewRevision, WorkspaceRevision};
+use flowy_folder_data_model::revision::{AppRevision, FolderRevision, ViewRevision, WorkspaceRevision};
 use flowy_revision::disk::SQLiteTextBlockRevisionPersistence;
-use flowy_revision::{RevisionLoader, RevisionPersistence};
+use flowy_revision::reset::{RevisionResettable, RevisionStructReset};
+use flowy_sync::client_folder::make_folder_rev_json_str;
+use flowy_sync::entities::revision::Revision;
 use flowy_sync::{client_folder::FolderPad, entities::revision::md5};
 use std::sync::Arc;
 
 const V1_MIGRATION: &str = "FOLDER_V1_MIGRATION";
 const V2_MIGRATION: &str = "FOLDER_V2_MIGRATION";
+#[allow(dead_code)]
+const V3_MIGRATION: &str = "FOLDER_V3_MIGRATION";
 
 pub(crate) struct FolderMigration {
     user_id: String,
@@ -29,7 +32,7 @@ impl FolderMigration {
     }
 
     pub fn run_v1_migration(&self) -> FlowyResult<Option<FolderPad>> {
-        let key = md5(format!("{}{}", self.user_id, V1_MIGRATION));
+        let key = migration_flag_key(&self.user_id, V1_MIGRATION);
         if KV::get_bool(&key) {
             return Ok(None);
         }
@@ -79,32 +82,63 @@ impl FolderMigration {
         Ok(Some(folder))
     }
 
-    pub async fn run_v2_migration(&self, user_id: &str, folder_id: &FolderId) -> FlowyResult<Option<FolderPad>> {
-        let key = md5(format!("{}{}", self.user_id, V2_MIGRATION));
+    pub async fn run_v2_migration(&self, folder_id: &FolderId) -> FlowyResult<()> {
+        let key = migration_flag_key(&self.user_id, V2_MIGRATION);
         if KV::get_bool(&key) {
-            return Ok(None);
+            return Ok(());
         }
-        let pool = self.database.db_pool()?;
-        let disk_cache = SQLiteTextBlockRevisionPersistence::new(user_id, pool);
-        let rev_persistence = Arc::new(RevisionPersistence::new(user_id, folder_id.as_ref(), disk_cache));
-        let (revisions, _) = RevisionLoader {
-            object_id: folder_id.as_ref().to_owned(),
-            user_id: self.user_id.clone(),
-            cloud: None,
-            rev_persistence,
-        }
-        .load()
-        .await?;
-
-        if revisions.is_empty() {
-            tracing::trace!("Run folder v2 migration, but revision is empty");
-            KV::set_bool(&key, true);
-            return Ok(None);
-        }
-
-        let pad = FolderPad::from_revisions(revisions)?;
+        let _ = self.migration_folder_rev_struct(folder_id).await?;
         KV::set_bool(&key, true);
         tracing::trace!("Run folder v2 migration");
-        Ok(Some(pad))
+        Ok(())
+    }
+
+    #[allow(dead_code)]
+    pub async fn run_v3_migration(&self, folder_id: &FolderId) -> FlowyResult<()> {
+        let key = migration_flag_key(&self.user_id, V3_MIGRATION);
+        if KV::get_bool(&key) {
+            return Ok(());
+        }
+        let _ = self.migration_folder_rev_struct(folder_id).await?;
+        KV::set_bool(&key, true);
+        tracing::trace!("Run folder v3 migration");
+        Ok(())
+    }
+
+    pub async fn migration_folder_rev_struct(&self, folder_id: &FolderId) -> FlowyResult<()> {
+        let object = FolderRevisionResettable {
+            folder_id: folder_id.as_ref().to_owned(),
+        };
+
+        let pool = self.database.db_pool()?;
+        let disk_cache = SQLiteTextBlockRevisionPersistence::new(&self.user_id, pool);
+        let reset = RevisionStructReset::new(&self.user_id, object, Arc::new(disk_cache));
+        reset.run().await
+    }
+}
+
+fn migration_flag_key(user_id: &str, version: &str) -> String {
+    md5(format!("{}{}", user_id, version,))
+}
+
+pub struct FolderRevisionResettable {
+    folder_id: String,
+}
+
+impl RevisionResettable for FolderRevisionResettable {
+    fn target_id(&self) -> &str {
+        &self.folder_id
+    }
+
+    fn target_reset_rev_str(&self, revisions: Vec<Revision>) -> FlowyResult<String> {
+        let pad = FolderPad::from_revisions(revisions)?;
+        let json = pad.to_json()?;
+        Ok(json)
+    }
+
+    fn default_target_rev_str(&self) -> FlowyResult<String> {
+        let folder = FolderRevision::default();
+        let json = make_folder_rev_json_str(&folder)?;
+        Ok(json)
     }
 }

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

@@ -100,10 +100,9 @@ impl FolderPersistence {
             self.save_folder(user_id, folder_id, migrated_folder).await?;
         }
 
-        if let Some(migrated_folder) = migrations.run_v2_migration(user_id, folder_id).await? {
-            self.save_folder(user_id, folder_id, migrated_folder).await?;
-        }
+        let _ = migrations.run_v2_migration(folder_id).await?;
 
+        // let _ = migrations.run_v3_migration(folder_id).await?;
         Ok(())
     }
 

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

@@ -96,7 +96,7 @@ impl GridManager {
     pub async fn open_grid<T: AsRef<str>>(&self, grid_id: T) -> FlowyResult<Arc<GridRevisionEditor>> {
         let grid_id = grid_id.as_ref();
         tracing::Span::current().record("grid_id", &grid_id);
-        let _ = self.migration.migration_grid_if_need(grid_id).await;
+        let _ = self.migration.run_v1_migration(grid_id).await;
         self.get_or_create_grid_editor(grid_id).await
     }
 
@@ -193,7 +193,7 @@ pub async fn make_grid_view_data(
     grid_manager: Arc<GridManager>,
     build_context: BuildGridContext,
 ) -> FlowyResult<Bytes> {
-    for block_meta_data in &build_context.blocks_meta_data {
+    for block_meta_data in &build_context.blocks {
         let block_id = &block_meta_data.block_id;
         // Indexing the block's rows
         block_meta_data.rows.iter().for_each(|row| {
@@ -208,6 +208,7 @@ pub async fn make_grid_view_data(
         let _ = grid_manager.create_grid_block(&block_id, repeated_revision).await?;
     }
 
+    // Will replace the grid_id with the value returned by the gen_grid_id()
     let grid_id = view_id.to_owned();
     let grid_rev = GridRevision::from_build_context(&grid_id, build_context);
 
@@ -219,7 +220,7 @@ pub async fn make_grid_view_data(
     let _ = grid_manager.create_grid(&grid_id, repeated_revision).await?;
 
     // Create grid view
-    let grid_view = GridViewRevision::new(view_id.to_owned(), view_id.to_owned());
+    let grid_view = GridViewRevision::new(grid_id, view_id.to_owned());
     let grid_view_delta = make_grid_view_delta(&grid_view);
     let grid_view_delta_bytes = grid_view_delta.json_bytes();
     let repeated_revision: RepeatedRevision =

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

@@ -546,8 +546,8 @@ impl GridRevisionEditor {
 
         Ok(BuildGridContext {
             field_revs: duplicated_fields.into_iter().map(Arc::new).collect(),
-            blocks: duplicated_blocks,
-            blocks_meta_data,
+            block_metas: duplicated_blocks,
+            blocks: blocks_meta_data,
         })
     }
 

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

@@ -1,23 +1,18 @@
+use crate::entities::{CreateRowParams, GridFilterConfiguration, GridSettingPB, RepeatedGridGroupPB, RowPB};
 use crate::manager::GridUser;
+use crate::services::block_manager::GridBlockManager;
+use crate::services::grid_editor_task::GridServiceTaskScheduler;
 use crate::services::grid_view_editor::{GridViewRevisionDataSource, GridViewRevisionDelegate, GridViewRevisionEditor};
 use bytes::Bytes;
-
-use crate::entities::{CreateRowParams, GridFilterConfiguration, GridSettingPB, RepeatedGridGroupPB, RowPB};
-use crate::services::grid_editor_task::GridServiceTaskScheduler;
-
-use crate::services::block_manager::GridBlockManager;
 use dashmap::DashMap;
 use flowy_error::FlowyResult;
 use flowy_grid_data_model::revision::{FieldRevision, RowRevision};
 use flowy_revision::disk::SQLiteGridViewRevisionPersistence;
 use flowy_revision::{RevisionCompactor, RevisionManager, RevisionPersistence, SQLiteRevisionSnapshotPersistence};
 use flowy_sync::client_grid::GridRevisionPad;
-use flowy_sync::entities::revision::Revision;
-
-use flowy_sync::util::make_text_delta_from_revisions;
-
 use flowy_sync::entities::grid::GridSettingChangesetParams;
-
+use flowy_sync::entities::revision::Revision;
+use flowy_sync::util::make_text_delta_from_revisions;
 use lib_infra::future::{wrap_future, AFFuture};
 use std::sync::Arc;
 use tokio::sync::RwLock;

frontend/rust-lib/flowy-grid/src/services/persistence/migration.rs

@@ -1,19 +1,17 @@
 use crate::manager::GridUser;
-
 use crate::services::persistence::GridDatabase;
 use flowy_database::kv::KV;
 use flowy_error::FlowyResult;
 use flowy_grid_data_model::revision::GridRevision;
-use flowy_revision::disk::{RevisionRecord, SQLiteGridRevisionPersistence};
-use flowy_revision::{mk_grid_block_revision_disk_cache, RevisionLoader, RevisionPersistence};
+use flowy_revision::disk::SQLiteGridRevisionPersistence;
+use flowy_revision::reset::{RevisionResettable, RevisionStructReset};
 use flowy_sync::client_grid::{make_grid_rev_json_str, GridRevisionPad};
 use flowy_sync::entities::revision::Revision;
-
-use lib_ot::core::TextDeltaBuilder;
-use serde::{Deserialize, Serialize};
-use std::str::FromStr;
+use flowy_sync::util::md5;
 use std::sync::Arc;
 
+const V1_MIGRATION: &str = "GRID_V1_MIGRATION";
+
 pub(crate) struct GridMigration {
     user: Arc<dyn GridUser>,
     database: Arc<dyn GridDatabase>,
@@ -24,90 +22,52 @@ impl GridMigration {
         Self { user, database }
     }
 
-    pub async fn migration_grid_if_need(&self, grid_id: &str) -> FlowyResult<()> {
-        match KV::get_str(grid_id) {
-            None => {
-                let _ = self.reset_grid_rev(grid_id).await?;
-                let _ = self.save_migrate_record(grid_id)?;
-            }
-            Some(s) => {
-                let mut record = MigrationGridRecord::from_str(&s)?;
-                let empty_json = self.empty_grid_rev_json()?;
-                if record.len < empty_json.len() {
-                    let _ = self.reset_grid_rev(grid_id).await?;
-                    record.len = empty_json.len();
-                    KV::set_str(grid_id, record.to_string());
-                }
-            }
-        }
-        Ok(())
-    }
-
-    async fn reset_grid_rev(&self, grid_id: &str) -> FlowyResult<()> {
+    pub async fn run_v1_migration(&self, grid_id: &str) -> FlowyResult<()> {
         let user_id = self.user.user_id()?;
-        let pool = self.database.db_pool()?;
-        let grid_rev_pad = self.get_grid_revision_pad(grid_id).await?;
-        let json = grid_rev_pad.json_str()?;
-        let delta_data = TextDeltaBuilder::new().insert(&json).build().json_bytes();
-        let revision = Revision::initial_revision(&user_id, grid_id, delta_data);
-        let record = RevisionRecord::new(revision);
-        //
-        let disk_cache = mk_grid_block_revision_disk_cache(&user_id, pool);
-        let _ = disk_cache.delete_and_insert_records(grid_id, None, vec![record]);
+        let key = migration_flag_key(&user_id, V1_MIGRATION, grid_id);
+        if KV::get_bool(&key) {
+            return Ok(());
+        }
+        let _ = self.migration_grid_rev_struct(grid_id).await?;
+        tracing::trace!("Run grid:{} v1 migration", grid_id);
+        KV::set_bool(&key, true);
         Ok(())
     }
 
-    fn save_migrate_record(&self, grid_id: &str) -> FlowyResult<()> {
-        let empty_json_str = self.empty_grid_rev_json()?;
-        let record = MigrationGridRecord {
+    pub async fn migration_grid_rev_struct(&self, grid_id: &str) -> FlowyResult<()> {
+        let object = GridRevisionResettable {
             grid_id: grid_id.to_owned(),
-            len: empty_json_str.len(),
         };
-        KV::set_str(grid_id, record.to_string());
-        Ok(())
-    }
-
-    fn empty_grid_rev_json(&self) -> FlowyResult<String> {
-        let empty_grid_rev = GridRevision::default();
-        let empty_json = make_grid_rev_json_str(&empty_grid_rev)?;
-        Ok(empty_json)
-    }
-
-    async fn get_grid_revision_pad(&self, grid_id: &str) -> FlowyResult<GridRevisionPad> {
-        let pool = self.database.db_pool()?;
         let user_id = self.user.user_id()?;
+        let pool = self.database.db_pool()?;
         let disk_cache = SQLiteGridRevisionPersistence::new(&user_id, pool);
-        let rev_persistence = Arc::new(RevisionPersistence::new(&user_id, grid_id, disk_cache));
-        let (revisions, _) = RevisionLoader {
-            object_id: grid_id.to_owned(),
-            user_id,
-            cloud: None,
-            rev_persistence,
-        }
-        .load()
-        .await?;
-
-        let pad = GridRevisionPad::from_revisions(revisions)?;
-        Ok(pad)
+        let reset = RevisionStructReset::new(&user_id, object, Arc::new(disk_cache));
+        reset.run().await
     }
 }
 
-#[derive(Serialize, Deserialize)]
-struct MigrationGridRecord {
+fn migration_flag_key(user_id: &str, version: &str, grid_id: &str) -> String {
+    md5(format!("{}{}{}", user_id, version, grid_id,))
+}
+
+pub struct GridRevisionResettable {
     grid_id: String,
-    len: usize,
 }
 
-impl FromStr for MigrationGridRecord {
-    type Err = serde_json::Error;
+impl RevisionResettable for GridRevisionResettable {
+    fn target_id(&self) -> &str {
+        &self.grid_id
+    }
 
-    fn from_str(s: &str) -> Result<Self, Self::Err> {
-        serde_json::from_str::<MigrationGridRecord>(s)
-    }
-}
-
-impl ToString for MigrationGridRecord {
-    fn to_string(&self) -> String {
-        serde_json::to_string(self).unwrap_or_else(|_| "".to_string())
+    fn target_reset_rev_str(&self, revisions: Vec<Revision>) -> FlowyResult<String> {
+        let pad = GridRevisionPad::from_revisions(revisions)?;
+        let json = pad.json_str()?;
+        Ok(json)
+    }
+
+    fn default_target_rev_str(&self) -> FlowyResult<String> {
+        let grid_rev = GridRevision::default();
+        let json = make_grid_rev_json_str(&grid_rev)?;
+        Ok(json)
     }
 }

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

@@ -23,6 +23,7 @@ dashmap = "5"
 serde = { version = "1.0", features = ["derive"] }
 futures-util = "0.3.15"
 async-stream = "0.3.2"
+serde_json = {version = "1.0"}
 
 [features]
 flowy_unit_test = ["lib-ot/flowy_unit_test"]

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

@@ -8,9 +8,10 @@ pub use grid_block_impl::*;
 pub use grid_impl::*;
 pub use grid_view_impl::*;
 
-use flowy_error::FlowyResult;
+use flowy_error::{FlowyError, FlowyResult};
 use flowy_sync::entities::revision::{RevId, Revision, RevisionRange};
 use std::fmt::Debug;
+use std::sync::Arc;
 
 pub trait RevisionDiskCache: Sync + Send {
     type Error: Debug;
@@ -45,6 +46,50 @@ pub trait RevisionDiskCache: Sync + Send {
     ) -> Result<(), Self::Error>;
 }
 
+impl<T> RevisionDiskCache for Arc<T>
+where
+    T: RevisionDiskCache<Error = FlowyError>,
+{
+    type Error = FlowyError;
+
+    fn create_revision_records(&self, revision_records: Vec<RevisionRecord>) -> Result<(), Self::Error> {
+        (**self).create_revision_records(revision_records)
+    }
+
+    fn read_revision_records(
+        &self,
+        object_id: &str,
+        rev_ids: Option<Vec<i64>>,
+    ) -> Result<Vec<RevisionRecord>, Self::Error> {
+        (**self).read_revision_records(object_id, rev_ids)
+    }
+
+    fn read_revision_records_with_range(
+        &self,
+        object_id: &str,
+        range: &RevisionRange,
+    ) -> Result<Vec<RevisionRecord>, Self::Error> {
+        (**self).read_revision_records_with_range(object_id, range)
+    }
+
+    fn update_revision_record(&self, changesets: Vec<RevisionChangeset>) -> FlowyResult<()> {
+        (**self).update_revision_record(changesets)
+    }
+
+    fn delete_revision_records(&self, object_id: &str, rev_ids: Option<Vec<i64>>) -> Result<(), Self::Error> {
+        (**self).delete_revision_records(object_id, rev_ids)
+    }
+
+    fn delete_and_insert_records(
+        &self,
+        object_id: &str,
+        deleted_rev_ids: Option<Vec<i64>>,
+        inserted_records: Vec<RevisionRecord>,
+    ) -> Result<(), Self::Error> {
+        (**self).delete_and_insert_records(object_id, deleted_rev_ids, inserted_records)
+    }
+}
+
 #[derive(Clone, Debug)]
 pub struct RevisionRecord {
     pub revision: Revision,

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

@@ -1,2 +1,3 @@
 pub mod disk;
 pub(crate) mod memory;
+pub mod reset;

frontend/rust-lib/flowy-revision/src/cache/reset.rs

@@ -0,0 +1,115 @@
+use crate::disk::{RevisionDiskCache, RevisionRecord};
+use crate::{RevisionLoader, RevisionPersistence};
+use flowy_database::kv::KV;
+use flowy_error::{FlowyError, FlowyResult};
+use flowy_sync::entities::revision::Revision;
+use lib_ot::core::TextDeltaBuilder;
+use serde::{Deserialize, Serialize};
+use std::str::FromStr;
+use std::sync::Arc;
+
+pub trait RevisionResettable {
+    fn target_id(&self) -> &str;
+    // String in json format
+    fn target_reset_rev_str(&self, revisions: Vec<Revision>) -> FlowyResult<String>;
+
+    // String in json format
+    fn default_target_rev_str(&self) -> FlowyResult<String>;
+}
+
+pub struct RevisionStructReset<T> {
+    user_id: String,
+    target: T,
+    disk_cache: Arc<dyn RevisionDiskCache<Error = FlowyError>>,
+}
+
+impl<T> RevisionStructReset<T>
+where
+    T: RevisionResettable,
+{
+    pub fn new(user_id: &str, object: T, disk_cache: Arc<dyn RevisionDiskCache<Error = FlowyError>>) -> Self {
+        Self {
+            user_id: user_id.to_owned(),
+            target: object,
+            disk_cache,
+        }
+    }
+
+    pub async fn run(&self) -> FlowyResult<()> {
+        match KV::get_str(self.target.target_id()) {
+            None => {
+                tracing::trace!("😁 reset object");
+                let _ = self.reset_object().await?;
+                let _ = self.save_migrate_record()?;
+            }
+            Some(s) => {
+                let mut record = MigrationGridRecord::from_str(&s)?;
+                let rev_str = self.target.default_target_rev_str()?;
+                if record.len < rev_str.len() {
+                    let _ = self.reset_object().await?;
+                    record.len = rev_str.len();
+                    KV::set_str(self.target.target_id(), record.to_string());
+                }
+            }
+        }
+        Ok(())
+    }
+
+    async fn reset_object(&self) -> FlowyResult<()> {
+        let rev_persistence = Arc::new(RevisionPersistence::from_disk_cache(
+            &self.user_id,
+            self.target.target_id(),
+            self.disk_cache.clone(),
+        ));
+        let (revisions, _) = RevisionLoader {
+            object_id: self.target.target_id().to_owned(),
+            user_id: self.user_id.clone(),
+            cloud: None,
+            rev_persistence,
+        }
+        .load()
+        .await?;
+
+        let s = self.target.target_reset_rev_str(revisions)?;
+        let delta_data = TextDeltaBuilder::new().insert(&s).build().json_bytes();
+        let revision = Revision::initial_revision(&self.user_id, self.target.target_id(), delta_data);
+        let record = RevisionRecord::new(revision);
+
+        tracing::trace!("Reset {} revision record object", self.target.target_id());
+        let _ = self
+            .disk_cache
+            .delete_and_insert_records(self.target.target_id(), None, vec![record]);
+
+        Ok(())
+    }
+
+    fn save_migrate_record(&self) -> FlowyResult<()> {
+        let rev_str = self.target.default_target_rev_str()?;
+        let record = MigrationGridRecord {
+            object_id: self.target.target_id().to_owned(),
+            len: rev_str.len(),
+        };
+        KV::set_str(self.target.target_id(), record.to_string());
+        Ok(())
+    }
+}
+
+#[derive(Serialize, Deserialize)]
+struct MigrationGridRecord {
+    object_id: String,
+    len: usize,
+}
+
+impl FromStr for MigrationGridRecord {
+    type Err = serde_json::Error;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        serde_json::from_str::<MigrationGridRecord>(s)
+    }
+}
+
+impl ToString for MigrationGridRecord {
+    fn to_string(&self) -> String {
+        serde_json::to_string(self).unwrap_or_else(|_| "".to_string())
+    }
+}

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

@@ -28,9 +28,17 @@ impl RevisionPersistence {
     where
         C: 'static + RevisionDiskCache<Error = FlowyError>,
     {
+        let disk_cache = Arc::new(disk_cache) as Arc<dyn RevisionDiskCache<Error = FlowyError>>;
+        Self::from_disk_cache(user_id, object_id, disk_cache)
+    }
+
+    pub fn from_disk_cache(
+        user_id: &str,
+        object_id: &str,
+        disk_cache: Arc<dyn RevisionDiskCache<Error = FlowyError>>,
+    ) -> RevisionPersistence {
         let object_id = object_id.to_owned();
         let user_id = user_id.to_owned();
-        let disk_cache = Arc::new(disk_cache) as Arc<dyn RevisionDiskCache<Error = FlowyError>>;
         let sync_seq = RwLock::new(RevisionSyncSequence::new());
         let memory_cache = Arc::new(RevisionMemoryCache::new(&object_id, Arc::new(disk_cache.clone())));
         Self {

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

@@ -75,6 +75,7 @@ fn crate_log_filter(level: String) -> String {
     filters.push(format!("lib_ws={}", level));
     filters.push(format!("lib_infra={}", level));
     filters.push(format!("flowy_sync={}", level));
+    filters.push(format!("flowy_revision={}", level));
     // filters.push(format!("lib_dispatch={}", level));
 
     filters.push(format!("dart_ffi={}", "info"));

frontend/rust-lib/lib-dispatch/src/data.rs

@@ -57,7 +57,7 @@ where
         match self.into_inner().into_bytes() {
             Ok(bytes) => {
                 log::trace!("Serialize Data: {:?} to event response", std::any::type_name::<T>());
-                return ResponseBuilder::Ok().data(bytes).build();
+                ResponseBuilder::Ok().data(bytes).build()
             }
             Err(e) => e.into(),
         }

shared-lib/flowy-folder-data-model/src/revision/view_rev.rs

@@ -18,7 +18,7 @@ pub struct ViewRevision {
     #[serde(default)]
     pub data_type: ViewDataTypeRevision,
 
-    pub version: i64,
+    pub version: i64, // Deprecated
 
     pub belongings: Vec<ViewRevision>,
 

shared-lib/flowy-grid-data-model/src/revision/grid_rev.rs

@@ -38,7 +38,7 @@ impl GridRevision {
         Self {
             grid_id: grid_id.to_owned(),
             fields: context.field_revs,
-            blocks: context.blocks.into_iter().map(Arc::new).collect(),
+            blocks: context.block_metas.into_iter().map(Arc::new).collect(),
         }
     }
 }
@@ -186,8 +186,8 @@ pub trait TypeOptionDataDeserializer {
 #[derive(Clone, Default, Deserialize, Serialize)]
 pub struct BuildGridContext {
     pub field_revs: Vec<Arc<FieldRevision>>,
-    pub blocks: Vec<GridBlockMetaRevision>,
-    pub blocks_meta_data: Vec<GridBlockRevision>,
+    pub block_metas: Vec<GridBlockMetaRevision>,
+    pub blocks: Vec<GridBlockRevision>,
 }
 
 impl BuildGridContext {

shared-lib/flowy-sync/src/client_folder/folder_pad.rs

@@ -319,11 +319,16 @@ impl FolderPad {
     }
 
     pub fn to_json(&self) -> CollaborateResult<String> {
-        serde_json::to_string(&self.folder_rev)
-            .map_err(|e| CollaborateError::internal().context(format!("serial trash to json failed: {}", e)))
+        make_folder_rev_json_str(&self.folder_rev)
     }
 }
 
+pub fn make_folder_rev_json_str(folder_rev: &FolderRevision) -> CollaborateResult<String> {
+    let json = serde_json::to_string(folder_rev)
+        .map_err(|err| internal_error(format!("Serialize folder to json str failed. {:?}", err)))?;
+    Ok(json)
+}
+
 impl FolderPad {
     fn modify_workspaces<F>(&mut self, f: F) -> CollaborateResult<Option<FolderChangeset>>
     where

shared-lib/flowy-sync/src/client_grid/grid_builder.rs

@@ -18,8 +18,8 @@ impl std::default::Default for GridBuilder {
             rows: vec![],
         };
 
-        build_context.blocks.push(block_meta);
-        build_context.blocks_meta_data.push(block_meta_data);
+        build_context.block_metas.push(block_meta);
+        build_context.blocks.push(block_meta_data);
 
         GridBuilder { build_context }
     }
@@ -34,8 +34,8 @@ impl GridBuilder {
     }
 
     pub fn add_row(&mut self, row_rev: RowRevision) {
-        let block_meta_rev = self.build_context.blocks.first_mut().unwrap();
-        let block_rev = self.build_context.blocks_meta_data.first_mut().unwrap();
+        let block_meta_rev = self.build_context.block_metas.first_mut().unwrap();
+        let block_rev = self.build_context.blocks.first_mut().unwrap();
         block_rev.rows.push(Arc::new(row_rev));
         block_meta_rev.row_count += 1;
     }
@@ -50,7 +50,7 @@ impl GridBuilder {
     }
 
     pub fn block_id(&self) -> &str {
-        &self.build_context.blocks.first().unwrap().block_id
+        &self.build_context.block_metas.first().unwrap().block_id
     }
 
     pub fn build(self) -> BuildGridContext {