feat: move handles to flowy-block crate

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

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

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

@@ -52,6 +52,10 @@ color-eyre = { version = "0.5", default-features = false }
 criterion = "0.3"
 rand = "0.7.3"
 
+[build-dependencies]
+lib-infra = { path = "../../../shared-lib/lib-infra", features = ["protobuf_file_gen", "proto_gen"] }
+
 [features]
 http_server = []
-flowy_unit_test = ["lib-ot/flowy_unit_test", "flowy-sync/flowy_unit_test"]
+flowy_unit_test = ["lib-ot/flowy_unit_test", "flowy-sync/flowy_unit_test"]
+dart = ["lib-infra/dart"]

frontend/rust-lib/flowy-block/Flowy.toml

@@ -0,0 +1,3 @@
+
+proto_crates = ["src/event_map.rs", "src/entities.rs"]
+event_files = ["src/event_map.rs"]

frontend/rust-lib/flowy-block/build.rs

@@ -0,0 +1,9 @@
+use lib_infra::code_gen;
+
+fn main() {
+    let crate_name = env!("CARGO_PKG_NAME");
+    code_gen::protobuf_file::gen(crate_name, "./src/protobuf/proto");
+
+    #[cfg(feature = "dart")]
+    code_gen::dart_event::gen(crate_name);
+}

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

@@ -0,0 +1,64 @@
+use crate::errors::ErrorCode;
+use flowy_derive::{ProtoBuf, ProtoBuf_Enum};
+use std::convert::TryInto;
+
+#[derive(PartialEq, Debug, ProtoBuf_Enum, Clone)]
+pub enum ExportType {
+    Text = 0,
+    Markdown = 1,
+    Link = 2,
+}
+
+impl std::default::Default for ExportType {
+    fn default() -> Self {
+        ExportType::Text
+    }
+}
+
+impl std::convert::From<i32> for ExportType {
+    fn from(val: i32) -> Self {
+        match val {
+            0 => ExportType::Text,
+            1 => ExportType::Markdown,
+            2 => ExportType::Link,
+            _ => {
+                log::error!("Invalid export type: {}", val);
+                ExportType::Text
+            }
+        }
+    }
+}
+
+#[derive(Default, ProtoBuf)]
+pub struct ExportPayload {
+    #[pb(index = 1)]
+    pub view_id: String,
+
+    #[pb(index = 2)]
+    pub export_type: ExportType,
+}
+
+#[derive(Default, Debug)]
+pub struct ExportParams {
+    pub view_id: String,
+    pub export_type: ExportType,
+}
+
+impl TryInto<ExportParams> for ExportPayload {
+    type Error = ErrorCode;
+    fn try_into(self) -> Result<ExportParams, Self::Error> {
+        Ok(ExportParams {
+            view_id: self.view_id,
+            export_type: self.export_type,
+        })
+    }
+}
+
+#[derive(Default, ProtoBuf)]
+pub struct ExportData {
+    #[pb(index = 1)]
+    pub data: String,
+
+    #[pb(index = 2)]
+    pub export_type: ExportType,
+}

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

@@ -0,0 +1,29 @@
+use crate::entities::{ExportData, ExportParams, ExportPayload};
+use crate::BlockManager;
+use flowy_collaboration::entities::document_info::BlockDelta;
+use flowy_error::FlowyError;
+use lib_dispatch::prelude::{data_result, AppData, Data, DataResult};
+use std::convert::TryInto;
+use std::sync::Arc;
+
+pub(crate) async fn apply_delta_handler(
+    data: Data<BlockDelta>,
+    manager: AppData<Arc<BlockManager>>,
+) -> DataResult<BlockDelta, FlowyError> {
+    let block_delta = manager.receive_local_delta(data.into_inner()).await?;
+    data_result(block_delta)
+}
+
+#[tracing::instrument(skip(data, manager), err)]
+pub(crate) async fn export_handler(
+    data: Data<ExportPayload>,
+    manager: AppData<Arc<BlockManager>>,
+) -> DataResult<ExportData, FlowyError> {
+    let params: ExportParams = data.into_inner().try_into()?;
+    let editor = manager.open_block(&params.view_id).await?;
+    let delta_json = editor.block_json().await?;
+    data_result(ExportData {
+        data: delta_json,
+        export_type: params.export_type,
+    })
+}

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

@@ -0,0 +1,26 @@
+use crate::event_handler::*;
+use crate::BlockManager;
+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<BlockManager>) -> Module {
+    let mut module = Module::new().name(env!("CARGO_PKG_NAME")).data(block_manager);
+
+    module = module
+        .event(BlockEvent::ApplyDocDelta, apply_delta_handler)
+        .event(BlockEvent::ExportDocument, export_handler);
+
+    module
+}
+
+#[derive(Clone, Copy, PartialEq, Eq, Debug, Display, Hash, ProtoBuf_Enum, Flowy_Event)]
+#[event_err = "FlowyError"]
+pub enum BlockEvent {
+    #[event(input = "BlockDelta", output = "BlockDelta")]
+    ApplyDocDelta = 0,
+
+    #[event(input = "ExportPayload", output = "ExportData")]
+    ExportDocument = 1,
+}

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

@@ -1,8 +1,12 @@
 pub mod block_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};

frontend/rust-lib/flowy-block/src/protobuf/mod.rs

@@ -0,0 +1,4 @@
+#![cfg_attr(rustfmt, rustfmt::skip)]
+// Auto-generated, do not edit
+mod model;
+pub use model::*;

frontend/rust-lib/flowy-block/src/protobuf/model/entities.rs

@@ -0,0 +1,478 @@
+// This file is generated by rust-protobuf 2.25.2. Do not edit
+// @generated
+
+// https://github.com/rust-lang/rust-clippy/issues/702
+#![allow(unknown_lints)]
+#![allow(clippy::all)]
+
+#![allow(unused_attributes)]
+#![cfg_attr(rustfmt, rustfmt::skip)]
+
+#![allow(box_pointers)]
+#![allow(dead_code)]
+#![allow(missing_docs)]
+#![allow(non_camel_case_types)]
+#![allow(non_snake_case)]
+#![allow(non_upper_case_globals)]
+#![allow(trivial_casts)]
+#![allow(unused_imports)]
+#![allow(unused_results)]
+//! Generated file from `entities.proto`
+
+/// Generated files are compatible only with the same version
+/// of protobuf runtime.
+// const _PROTOBUF_VERSION_CHECK: () = ::protobuf::VERSION_2_25_2;
+
+#[derive(PartialEq,Clone,Default)]
+pub struct ExportPayload {
+    // message fields
+    pub view_id: ::std::string::String,
+    pub export_type: ExportType,
+    // special fields
+    pub unknown_fields: ::protobuf::UnknownFields,
+    pub cached_size: ::protobuf::CachedSize,
+}
+
+impl<'a> ::std::default::Default for &'a ExportPayload {
+    fn default() -> &'a ExportPayload {
+        <ExportPayload as ::protobuf::Message>::default_instance()
+    }
+}
+
+impl ExportPayload {
+    pub fn new() -> ExportPayload {
+        ::std::default::Default::default()
+    }
+
+    // string view_id = 1;
+
+
+    pub fn get_view_id(&self) -> &str {
+        &self.view_id
+    }
+    pub fn clear_view_id(&mut self) {
+        self.view_id.clear();
+    }
+
+    // Param is passed by value, moved
+    pub fn set_view_id(&mut self, v: ::std::string::String) {
+        self.view_id = v;
+    }
+
+    // Mutable pointer to the field.
+    // If field is not initialized, it is initialized with default value first.
+    pub fn mut_view_id(&mut self) -> &mut ::std::string::String {
+        &mut self.view_id
+    }
+
+    // Take field
+    pub fn take_view_id(&mut self) -> ::std::string::String {
+        ::std::mem::replace(&mut self.view_id, ::std::string::String::new())
+    }
+
+    // .ExportType export_type = 2;
+
+
+    pub fn get_export_type(&self) -> ExportType {
+        self.export_type
+    }
+    pub fn clear_export_type(&mut self) {
+        self.export_type = ExportType::Text;
+    }
+
+    // Param is passed by value, moved
+    pub fn set_export_type(&mut self, v: ExportType) {
+        self.export_type = v;
+    }
+}
+
+impl ::protobuf::Message for ExportPayload {
+    fn is_initialized(&self) -> bool {
+        true
+    }
+
+    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
+        while !is.eof()? {
+            let (field_number, wire_type) = is.read_tag_unpack()?;
+            match field_number {
+                1 => {
+                    ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.view_id)?;
+                },
+                2 => {
+                    ::protobuf::rt::read_proto3_enum_with_unknown_fields_into(wire_type, is, &mut self.export_type, 2, &mut self.unknown_fields)?
+                },
+                _ => {
+                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
+                },
+            };
+        }
+        ::std::result::Result::Ok(())
+    }
+
+    // Compute sizes of nested messages
+    #[allow(unused_variables)]
+    fn compute_size(&self) -> u32 {
+        let mut my_size = 0;
+        if !self.view_id.is_empty() {
+            my_size += ::protobuf::rt::string_size(1, &self.view_id);
+        }
+        if self.export_type != ExportType::Text {
+            my_size += ::protobuf::rt::enum_size(2, self.export_type);
+        }
+        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
+        self.cached_size.set(my_size);
+        my_size
+    }
+
+    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
+        if !self.view_id.is_empty() {
+            os.write_string(1, &self.view_id)?;
+        }
+        if self.export_type != ExportType::Text {
+            os.write_enum(2, ::protobuf::ProtobufEnum::value(&self.export_type))?;
+        }
+        os.write_unknown_fields(self.get_unknown_fields())?;
+        ::std::result::Result::Ok(())
+    }
+
+    fn get_cached_size(&self) -> u32 {
+        self.cached_size.get()
+    }
+
+    fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
+        &self.unknown_fields
+    }
+
+    fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
+        &mut self.unknown_fields
+    }
+
+    fn as_any(&self) -> &dyn (::std::any::Any) {
+        self as &dyn (::std::any::Any)
+    }
+    fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
+        self as &mut dyn (::std::any::Any)
+    }
+    fn into_any(self: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
+        self
+    }
+
+    fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
+        Self::descriptor_static()
+    }
+
+    fn new() -> ExportPayload {
+        ExportPayload::new()
+    }
+
+    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
+        static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
+        descriptor.get(|| {
+            let mut fields = ::std::vec::Vec::new();
+            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
+                "view_id",
+                |m: &ExportPayload| { &m.view_id },
+                |m: &mut ExportPayload| { &mut m.view_id },
+            ));
+            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeEnum<ExportType>>(
+                "export_type",
+                |m: &ExportPayload| { &m.export_type },
+                |m: &mut ExportPayload| { &mut m.export_type },
+            ));
+            ::protobuf::reflect::MessageDescriptor::new_pb_name::<ExportPayload>(
+                "ExportPayload",
+                fields,
+                file_descriptor_proto()
+            )
+        })
+    }
+
+    fn default_instance() -> &'static ExportPayload {
+        static instance: ::protobuf::rt::LazyV2<ExportPayload> = ::protobuf::rt::LazyV2::INIT;
+        instance.get(ExportPayload::new)
+    }
+}
+
+impl ::protobuf::Clear for ExportPayload {
+    fn clear(&mut self) {
+        self.view_id.clear();
+        self.export_type = ExportType::Text;
+        self.unknown_fields.clear();
+    }
+}
+
+impl ::std::fmt::Debug for ExportPayload {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
+        ::protobuf::text_format::fmt(self, f)
+    }
+}
+
+impl ::protobuf::reflect::ProtobufValue for ExportPayload {
+    fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
+        ::protobuf::reflect::ReflectValueRef::Message(self)
+    }
+}
+
+#[derive(PartialEq,Clone,Default)]
+pub struct ExportData {
+    // message fields
+    pub data: ::std::string::String,
+    pub export_type: ExportType,
+    // special fields
+    pub unknown_fields: ::protobuf::UnknownFields,
+    pub cached_size: ::protobuf::CachedSize,
+}
+
+impl<'a> ::std::default::Default for &'a ExportData {
+    fn default() -> &'a ExportData {
+        <ExportData as ::protobuf::Message>::default_instance()
+    }
+}
+
+impl ExportData {
+    pub fn new() -> ExportData {
+        ::std::default::Default::default()
+    }
+
+    // string data = 1;
+
+
+    pub fn get_data(&self) -> &str {
+        &self.data
+    }
+    pub fn clear_data(&mut self) {
+        self.data.clear();
+    }
+
+    // Param is passed by value, moved
+    pub fn set_data(&mut self, v: ::std::string::String) {
+        self.data = v;
+    }
+
+    // Mutable pointer to the field.
+    // If field is not initialized, it is initialized with default value first.
+    pub fn mut_data(&mut self) -> &mut ::std::string::String {
+        &mut self.data
+    }
+
+    // Take field
+    pub fn take_data(&mut self) -> ::std::string::String {
+        ::std::mem::replace(&mut self.data, ::std::string::String::new())
+    }
+
+    // .ExportType export_type = 2;
+
+
+    pub fn get_export_type(&self) -> ExportType {
+        self.export_type
+    }
+    pub fn clear_export_type(&mut self) {
+        self.export_type = ExportType::Text;
+    }
+
+    // Param is passed by value, moved
+    pub fn set_export_type(&mut self, v: ExportType) {
+        self.export_type = v;
+    }
+}
+
+impl ::protobuf::Message for ExportData {
+    fn is_initialized(&self) -> bool {
+        true
+    }
+
+    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
+        while !is.eof()? {
+            let (field_number, wire_type) = is.read_tag_unpack()?;
+            match field_number {
+                1 => {
+                    ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.data)?;
+                },
+                2 => {
+                    ::protobuf::rt::read_proto3_enum_with_unknown_fields_into(wire_type, is, &mut self.export_type, 2, &mut self.unknown_fields)?
+                },
+                _ => {
+                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
+                },
+            };
+        }
+        ::std::result::Result::Ok(())
+    }
+
+    // Compute sizes of nested messages
+    #[allow(unused_variables)]
+    fn compute_size(&self) -> u32 {
+        let mut my_size = 0;
+        if !self.data.is_empty() {
+            my_size += ::protobuf::rt::string_size(1, &self.data);
+        }
+        if self.export_type != ExportType::Text {
+            my_size += ::protobuf::rt::enum_size(2, self.export_type);
+        }
+        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
+        self.cached_size.set(my_size);
+        my_size
+    }
+
+    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
+        if !self.data.is_empty() {
+            os.write_string(1, &self.data)?;
+        }
+        if self.export_type != ExportType::Text {
+            os.write_enum(2, ::protobuf::ProtobufEnum::value(&self.export_type))?;
+        }
+        os.write_unknown_fields(self.get_unknown_fields())?;
+        ::std::result::Result::Ok(())
+    }
+
+    fn get_cached_size(&self) -> u32 {
+        self.cached_size.get()
+    }
+
+    fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
+        &self.unknown_fields
+    }
+
+    fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
+        &mut self.unknown_fields
+    }
+
+    fn as_any(&self) -> &dyn (::std::any::Any) {
+        self as &dyn (::std::any::Any)
+    }
+    fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
+        self as &mut dyn (::std::any::Any)
+    }
+    fn into_any(self: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
+        self
+    }
+
+    fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
+        Self::descriptor_static()
+    }
+
+    fn new() -> ExportData {
+        ExportData::new()
+    }
+
+    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
+        static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
+        descriptor.get(|| {
+            let mut fields = ::std::vec::Vec::new();
+            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
+                "data",
+                |m: &ExportData| { &m.data },
+                |m: &mut ExportData| { &mut m.data },
+            ));
+            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeEnum<ExportType>>(
+                "export_type",
+                |m: &ExportData| { &m.export_type },
+                |m: &mut ExportData| { &mut m.export_type },
+            ));
+            ::protobuf::reflect::MessageDescriptor::new_pb_name::<ExportData>(
+                "ExportData",
+                fields,
+                file_descriptor_proto()
+            )
+        })
+    }
+
+    fn default_instance() -> &'static ExportData {
+        static instance: ::protobuf::rt::LazyV2<ExportData> = ::protobuf::rt::LazyV2::INIT;
+        instance.get(ExportData::new)
+    }
+}
+
+impl ::protobuf::Clear for ExportData {
+    fn clear(&mut self) {
+        self.data.clear();
+        self.export_type = ExportType::Text;
+        self.unknown_fields.clear();
+    }
+}
+
+impl ::std::fmt::Debug for ExportData {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
+        ::protobuf::text_format::fmt(self, f)
+    }
+}
+
+impl ::protobuf::reflect::ProtobufValue for ExportData {
+    fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
+        ::protobuf::reflect::ReflectValueRef::Message(self)
+    }
+}
+
+#[derive(Clone,PartialEq,Eq,Debug,Hash)]
+pub enum ExportType {
+    Text = 0,
+    Markdown = 1,
+    Link = 2,
+}
+
+impl ::protobuf::ProtobufEnum for ExportType {
+    fn value(&self) -> i32 {
+        *self as i32
+    }
+
+    fn from_i32(value: i32) -> ::std::option::Option<ExportType> {
+        match value {
+            0 => ::std::option::Option::Some(ExportType::Text),
+            1 => ::std::option::Option::Some(ExportType::Markdown),
+            2 => ::std::option::Option::Some(ExportType::Link),
+            _ => ::std::option::Option::None
+        }
+    }
+
+    fn values() -> &'static [Self] {
+        static values: &'static [ExportType] = &[
+            ExportType::Text,
+            ExportType::Markdown,
+            ExportType::Link,
+        ];
+        values
+    }
+
+    fn enum_descriptor_static() -> &'static ::protobuf::reflect::EnumDescriptor {
+        static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::EnumDescriptor> = ::protobuf::rt::LazyV2::INIT;
+        descriptor.get(|| {
+            ::protobuf::reflect::EnumDescriptor::new_pb_name::<ExportType>("ExportType", file_descriptor_proto())
+        })
+    }
+}
+
+impl ::std::marker::Copy for ExportType {
+}
+
+impl ::std::default::Default for ExportType {
+    fn default() -> Self {
+        ExportType::Text
+    }
+}
+
+impl ::protobuf::reflect::ProtobufValue for ExportType {
+    fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
+        ::protobuf::reflect::ReflectValueRef::Enum(::protobuf::ProtobufEnum::descriptor(self))
+    }
+}
+
+static file_descriptor_proto_data: &'static [u8] = b"\
+    \n\x0eentities.proto\"V\n\rExportPayload\x12\x17\n\x07view_id\x18\x01\
+    \x20\x01(\tR\x06viewId\x12,\n\x0bexport_type\x18\x02\x20\x01(\x0e2\x0b.E\
+    xportTypeR\nexportType\"N\n\nExportData\x12\x12\n\x04data\x18\x01\x20\
+    \x01(\tR\x04data\x12,\n\x0bexport_type\x18\x02\x20\x01(\x0e2\x0b.ExportT\
+    ypeR\nexportType*.\n\nExportType\x12\x08\n\x04Text\x10\0\x12\x0c\n\x08Ma\
+    rkdown\x10\x01\x12\x08\n\x04Link\x10\x02b\x06proto3\
+";
+
+static file_descriptor_proto_lazy: ::protobuf::rt::LazyV2<::protobuf::descriptor::FileDescriptorProto> = ::protobuf::rt::LazyV2::INIT;
+
+fn parse_descriptor_proto() -> ::protobuf::descriptor::FileDescriptorProto {
+    ::protobuf::Message::parse_from_bytes(file_descriptor_proto_data).unwrap()
+}
+
+pub fn file_descriptor_proto() -> &'static ::protobuf::descriptor::FileDescriptorProto {
+    file_descriptor_proto_lazy.get(|| {
+        parse_descriptor_proto()
+    })
+}

frontend/rust-lib/flowy-block/src/protobuf/model/event_map.rs

@@ -0,0 +1,91 @@
+// This file is generated by rust-protobuf 2.25.2. Do not edit
+// @generated
+
+// https://github.com/rust-lang/rust-clippy/issues/702
+#![allow(unknown_lints)]
+#![allow(clippy::all)]
+
+#![allow(unused_attributes)]
+#![cfg_attr(rustfmt, rustfmt::skip)]
+
+#![allow(box_pointers)]
+#![allow(dead_code)]
+#![allow(missing_docs)]
+#![allow(non_camel_case_types)]
+#![allow(non_snake_case)]
+#![allow(non_upper_case_globals)]
+#![allow(trivial_casts)]
+#![allow(unused_imports)]
+#![allow(unused_results)]
+//! Generated file from `event_map.proto`
+
+/// Generated files are compatible only with the same version
+/// of protobuf runtime.
+// const _PROTOBUF_VERSION_CHECK: () = ::protobuf::VERSION_2_25_2;
+
+#[derive(Clone,PartialEq,Eq,Debug,Hash)]
+pub enum BlockEvent {
+    ApplyDocDelta = 0,
+    ExportDocument = 1,
+}
+
+impl ::protobuf::ProtobufEnum for BlockEvent {
+    fn value(&self) -> i32 {
+        *self as i32
+    }
+
+    fn from_i32(value: i32) -> ::std::option::Option<BlockEvent> {
+        match value {
+            0 => ::std::option::Option::Some(BlockEvent::ApplyDocDelta),
+            1 => ::std::option::Option::Some(BlockEvent::ExportDocument),
+            _ => ::std::option::Option::None
+        }
+    }
+
+    fn values() -> &'static [Self] {
+        static values: &'static [BlockEvent] = &[
+            BlockEvent::ApplyDocDelta,
+            BlockEvent::ExportDocument,
+        ];
+        values
+    }
+
+    fn enum_descriptor_static() -> &'static ::protobuf::reflect::EnumDescriptor {
+        static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::EnumDescriptor> = ::protobuf::rt::LazyV2::INIT;
+        descriptor.get(|| {
+            ::protobuf::reflect::EnumDescriptor::new_pb_name::<BlockEvent>("BlockEvent", file_descriptor_proto())
+        })
+    }
+}
+
+impl ::std::marker::Copy for BlockEvent {
+}
+
+impl ::std::default::Default for BlockEvent {
+    fn default() -> Self {
+        BlockEvent::ApplyDocDelta
+    }
+}
+
+impl ::protobuf::reflect::ProtobufValue for BlockEvent {
+    fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
+        ::protobuf::reflect::ReflectValueRef::Enum(::protobuf::ProtobufEnum::descriptor(self))
+    }
+}
+
+static file_descriptor_proto_data: &'static [u8] = b"\
+    \n\x0fevent_map.proto*3\n\nBlockEvent\x12\x11\n\rApplyDocDelta\x10\0\x12\
+    \x12\n\x0eExportDocument\x10\x01b\x06proto3\
+";
+
+static file_descriptor_proto_lazy: ::protobuf::rt::LazyV2<::protobuf::descriptor::FileDescriptorProto> = ::protobuf::rt::LazyV2::INIT;
+
+fn parse_descriptor_proto() -> ::protobuf::descriptor::FileDescriptorProto {
+    ::protobuf::Message::parse_from_bytes(file_descriptor_proto_data).unwrap()
+}
+
+pub fn file_descriptor_proto() -> &'static ::protobuf::descriptor::FileDescriptorProto {
+    file_descriptor_proto_lazy.get(|| {
+        parse_descriptor_proto()
+    })
+}

frontend/rust-lib/flowy-block/src/protobuf/model/mod.rs

@@ -0,0 +1,8 @@
+#![cfg_attr(rustfmt, rustfmt::skip)]
+// Auto-generated, do not edit
+
+mod entities;
+pub use entities::*;
+
+mod event_map;
+pub use event_map::*;

frontend/rust-lib/flowy-block/src/protobuf/proto/entities.proto

@@ -0,0 +1,15 @@
+syntax = "proto3";
+
+message ExportPayload {
+    string view_id = 1;
+    ExportType export_type = 2;
+}
+message ExportData {
+    string data = 1;
+    ExportType export_type = 2;
+}
+enum ExportType {
+    Text = 0;
+    Markdown = 1;
+    Link = 2;
+}

frontend/rust-lib/flowy-block/src/protobuf/proto/event_map.proto

@@ -0,0 +1,6 @@
+syntax = "proto3";
+
+enum BlockEvent {
+    ApplyDocDelta = 0;
+    ExportDocument = 1;
+}

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

@@ -27,7 +27,7 @@ impl EditorTest {
         let sdk = FlowySDKTest::default();
         let _ = sdk.init_user().await;
         let test = ViewTest::new(&sdk).await;
-        let editor = sdk.document_manager.open_block(&test.view.id).await.unwrap();
+        let editor = sdk.block_manager.open_block(&test.view.id).await.unwrap();
         Self { sdk, editor }
     }
 

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

@@ -1,5 +1,4 @@
 use crate::{
-    controller::FolderManager,
     entities::{
         app::{App, AppId, CreateAppParams, UpdateAppParams},
         trash::{RepeatedTrash, RepeatedTrashId},
@@ -7,6 +6,7 @@ use crate::{
         workspace::{CreateWorkspaceParams, RepeatedWorkspace, UpdateWorkspaceParams, Workspace, WorkspaceId},
     },
     errors::FlowyError,
+    manager::FolderManager,
     services::{app::event_handler::*, trash::event_handler::*, view::event_handler::*, workspace::event_handler::*},
 };
 use flowy_database::DBConnection;
@@ -64,8 +64,7 @@ pub fn create(folder: Arc<FolderManager>) -> Module {
         .event(FolderEvent::DeleteView, delete_view_handler)
         .event(FolderEvent::DuplicateView, duplicate_view_handler)
         .event(FolderEvent::OpenView, open_view_handler)
-        .event(FolderEvent::CloseView, close_view_handler)
-        .event(FolderEvent::ApplyDocDelta, block_delta_handler);
+        .event(FolderEvent::CloseView, close_view_handler);
 
     module = module
         .event(FolderEvent::ReadTrash, read_trash_handler)
@@ -74,8 +73,6 @@ pub fn create(folder: Arc<FolderManager>) -> Module {
         .event(FolderEvent::RestoreAllTrash, restore_all_trash_handler)
         .event(FolderEvent::DeleteAllTrash, delete_all_trash_handler);
 
-    module = module.event(FolderEvent::ExportDocument, export_handler);
-
     module
 }
 

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

@@ -8,8 +8,8 @@ mod macros;
 #[macro_use]
 extern crate flowy_database;
 
-pub mod controller;
 mod dart_notification;
+pub mod manager;
 pub mod protobuf;
 mod util;
 

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

@@ -72,7 +72,7 @@ impl FolderManager {
         user: Arc<dyn WorkspaceUser>,
         cloud_service: Arc<dyn FolderCouldServiceV1>,
         database: Arc<dyn WorkspaceDatabase>,
-        document_manager: Arc<BlockManager>,
+        block_manager: Arc<BlockManager>,
         web_socket: Arc<dyn RevisionWebSocket>,
     ) -> Self {
         if let Ok(user_id) = user.user_id() {
@@ -95,7 +95,7 @@ impl FolderManager {
             persistence.clone(),
             cloud_service.clone(),
             trash_controller.clone(),
-            document_manager,
+            block_manager,
         ));
 
         let app_controller = Arc::new(AppController::new(

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

@@ -4,7 +4,7 @@ use flowy_collaboration::{
     entities::{revision::Revision, ws_data::ServerRevisionWSData},
 };
 
-use crate::controller::FolderId;
+use crate::manager::FolderId;
 use flowy_collaboration::util::make_delta_from_revisions;
 use flowy_error::{FlowyError, FlowyResult};
 use flowy_sync::{

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

@@ -1,4 +1,4 @@
-use crate::controller::FolderId;
+use crate::manager::FolderId;
 use crate::{
     event_map::WorkspaceDatabase,
     services::persistence::{AppTableSql, TrashTableSql, ViewTableSql, WorkspaceTableSql},

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

@@ -12,8 +12,8 @@ use tokio::sync::RwLock;
 pub use version_1::{app_sql::*, trash_sql::*, v1_impl::V1Transaction, view_sql::*, workspace_sql::*};
 
 use crate::{
-    controller::FolderId,
     event_map::WorkspaceDatabase,
+    manager::FolderId,
     services::{folder_editor::ClientFolderEditor, persistence::migration::FolderMigration},
 };
 use flowy_error::{FlowyError, FlowyResult};

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

@@ -23,8 +23,6 @@ use crate::{
 };
 use flowy_block::BlockManager;
 use flowy_database::kv::KV;
-use flowy_folder_data_model::entities::share::{ExportData, ExportParams};
-
 use lib_infra::uuid;
 
 const LATEST_VIEW_ID: &str = "latest_view_id";
@@ -179,16 +177,6 @@ impl ViewController {
         Ok(())
     }
 
-    #[tracing::instrument(level = "debug", skip(self, params), err)]
-    pub(crate) async fn export_view(&self, params: ExportParams) -> Result<ExportData, FlowyError> {
-        let editor = self.block_manager.open_block(&params.view_id).await?;
-        let delta_json = editor.block_json().await?;
-        Ok(ExportData {
-            data: delta_json,
-            export_type: params.export_type,
-        })
-    }
-
     // belong_to_id will be the app_id or view_id.
     #[tracing::instrument(level = "debug", skip(self), err)]
     pub(crate) async fn read_views_belong_to(&self, belong_to_id: &str) -> Result<RepeatedView, FlowyError> {

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

@@ -9,7 +9,6 @@ use crate::{
     services::{TrashController, ViewController},
 };
 use flowy_collaboration::entities::document_info::BlockDelta;
-use flowy_folder_data_model::entities::share::{ExportData, ExportParams, ExportPayload};
 use lib_dispatch::prelude::{data_result, AppData, Data, DataResult};
 use std::{convert::TryInto, sync::Arc};
 
@@ -46,14 +45,6 @@ pub(crate) async fn update_view_handler(
     Ok(())
 }
 
-pub(crate) async fn block_delta_handler(
-    data: Data<BlockDelta>,
-    controller: AppData<Arc<ViewController>>,
-) -> DataResult<BlockDelta, FlowyError> {
-    let block_delta = controller.receive_delta(data.into_inner()).await?;
-    data_result(block_delta)
-}
-
 pub(crate) async fn delete_view_handler(
     data: Data<RepeatedViewId>,
     view_controller: AppData<Arc<ViewController>>,
@@ -102,13 +93,3 @@ pub(crate) async fn duplicate_view_handler(
     let _ = controller.duplicate_view(&view_id.value).await?;
     Ok(())
 }
-
-#[tracing::instrument(skip(data, controller), err)]
-pub(crate) async fn export_handler(
-    data: Data<ExportPayload>,
-    controller: AppData<Arc<ViewController>>,
-) -> DataResult<ExportData, FlowyError> {
-    let params: ExportParams = data.into_inner().try_into()?;
-    let data = controller.export_view(params).await?;
-    data_result(data)
-}

frontend/rust-lib/flowy-folder/src/services/workspace/event_handler.rs

@@ -1,7 +1,7 @@
 use crate::{
-    controller::FolderManager,
     dart_notification::{send_dart_notification, FolderNotification},
     errors::FlowyError,
+    manager::FolderManager,
     services::{get_current_workspace, read_local_workspace_apps, WorkspaceController},
 };
 use flowy_folder_data_model::entities::{

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

@@ -13,7 +13,7 @@ flowy-net = { path = "../flowy-net" }
 flowy-folder = { path = "../flowy-folder", default-features = false }
 flowy-grid = { path = "../flowy-grid", default-features = false }
 flowy-database = { path = "../flowy-database" }
-flowy-block = { path = "../flowy-block" }
+flowy-block = { path = "../flowy-block", default-features = false }
 flowy-sync = { path = "../flowy-sync" }
 
 tracing = { version = "0.1" }
@@ -40,4 +40,4 @@ futures-util = "0.3.15"
 [features]
 http_server = ["flowy-user/http_server", "flowy-folder/http_server", "flowy-block/http_server"]
 use_bunyan = ["lib-log/use_bunyan"]
-dart = ["flowy-user/dart", "flowy-net/dart", "flowy-folder/dart", "flowy-collaboration/dart", "flowy-grid/dart"]
+dart = ["flowy-user/dart", "flowy-net/dart", "flowy-folder/dart", "flowy-collaboration/dart", "flowy-grid/dart", "flowy-block/dart"]

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

@@ -3,9 +3,9 @@ use flowy_block::BlockManager;
 use flowy_collaboration::entities::ws_data::ClientRevisionWSData;
 use flowy_database::ConnectionPool;
 use flowy_folder::{
-    controller::FolderManager,
     errors::{internal_error, FlowyError},
     event_map::{FolderCouldServiceV1, WorkspaceDatabase, WorkspaceUser},
+    manager::FolderManager,
 };
 use flowy_net::ClientServerConfiguration;
 use flowy_net::{
@@ -24,7 +24,7 @@ impl FolderDepsResolver {
         local_server: Option<Arc<LocalServer>>,
         user_session: Arc<UserSession>,
         server_config: &ClientServerConfiguration,
-        document_manager: &Arc<BlockManager>,
+        block_manager: &Arc<BlockManager>,
         ws_conn: Arc<FlowyWebSocketConnect>,
     ) -> Arc<FolderManager> {
         let user: Arc<dyn WorkspaceUser> = Arc::new(WorkspaceUserImpl(user_session.clone()));
@@ -36,14 +36,7 @@ impl FolderDepsResolver {
         };
 
         let folder_manager = Arc::new(
-            FolderManager::new(
-                user.clone(),
-                cloud_service,
-                database,
-                document_manager.clone(),
-                web_socket,
-            )
-            .await,
+            FolderManager::new(user.clone(), cloud_service, database, block_manager.clone(), web_socket).await,
         );
 
         if let (Ok(user_id), Ok(token)) = (user.user_id(), user.token()) {

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

@@ -4,7 +4,7 @@ pub use flowy_net::get_client_server_configuration;
 
 use crate::deps_resolve::*;
 use flowy_block::BlockManager;
-use flowy_folder::{controller::FolderManager, errors::FlowyError};
+use flowy_folder::{errors::FlowyError, manager::FolderManager};
 use flowy_grid::manager::GridManager;
 use flowy_net::ClientServerConfiguration;
 use flowy_net::{
@@ -87,7 +87,7 @@ pub struct FlowySDK {
     #[allow(dead_code)]
     config: FlowySDKConfig,
     pub user_session: Arc<UserSession>,
-    pub document_manager: Arc<BlockManager>,
+    pub block_manager: Arc<BlockManager>,
     pub folder_manager: Arc<FolderManager>,
     pub grid_manager: Arc<GridManager>,
     pub dispatcher: Arc<EventDispatcher>,
@@ -102,9 +102,9 @@ impl FlowySDK {
         tracing::debug!("🔥 {:?}", config);
         let runtime = tokio_default_runtime().unwrap();
         let (local_server, ws_conn) = mk_local_server(&config.server_config);
-        let (user_session, document_manager, folder_manager, local_server, grid_manager) = runtime.block_on(async {
+        let (user_session, 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 document_manager = BlockDepsResolver::resolve(
+            let block_manager = BlockDepsResolver::resolve(
                 local_server.clone(),
                 ws_conn.clone(),
                 user_session.clone(),
@@ -115,7 +115,7 @@ impl FlowySDK {
                 local_server.clone(),
                 user_session.clone(),
                 &config.server_config,
-                &document_manager,
+                &block_manager,
                 ws_conn.clone(),
             )
             .await;
@@ -126,17 +126,11 @@ impl FlowySDK {
                 local_server.run();
             }
             ws_conn.init().await;
-            (
-                user_session,
-                document_manager,
-                folder_manager,
-                local_server,
-                grid_manager,
-            )
+            (user_session, block_manager, folder_manager, local_server, grid_manager)
         });
 
         let dispatcher = Arc::new(EventDispatcher::construct(runtime, || {
-            mk_modules(&ws_conn, &folder_manager, &grid_manager, &user_session)
+            mk_modules(&ws_conn, &folder_manager, &grid_manager, &user_session, &block_manager)
         }));
 
         _start_listening(&dispatcher, &ws_conn, &user_session, &folder_manager);
@@ -144,7 +138,7 @@ impl FlowySDK {
         Self {
             config,
             user_session,
-            document_manager,
+            block_manager,
             folder_manager,
             grid_manager,
             dispatcher,

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

@@ -1,4 +1,5 @@
-use flowy_folder::controller::FolderManager;
+use flowy_block::BlockManager;
+use flowy_folder::manager::FolderManager;
 use flowy_grid::manager::GridManager;
 use flowy_net::ws::connection::FlowyWebSocketConnect;
 use flowy_user::services::UserSession;
@@ -10,6 +11,7 @@ pub fn mk_modules(
     folder_manager: &Arc<FolderManager>,
     grid_manager: &Arc<GridManager>,
     user_session: &Arc<UserSession>,
+    block_manager: &Arc<BlockManager>,
 ) -> Vec<Module> {
     let user_module = mk_user_module(user_session.clone());
     let folder_module = mk_folder_module(folder_manager.clone());
@@ -33,3 +35,7 @@ fn mk_network_module(ws_conn: Arc<FlowyWebSocketConnect>) -> Module {
 fn mk_grid_module(grid_manager: Arc<GridManager>) -> Module {
     flowy_grid::event_map::create(grid_manager)
 }
+
+fn mk_block_module(block_manager: Arc<BlockManager>) -> Module {
+    flowy_block::event_map::create(block_manager)
+}