add frontend folder

frontend/rust-lib/flowy-sdk/.gitignore

@@ -0,0 +1,12 @@
+# Generated by Cargo
+# will have compiled files and executables
+/target/
+
+# Remove Cargo.lock from gitignore if creating an executable, leave it for libraries
+# More information here https://doc.rust-lang.org/cargo/guide/cargo-toml-vs-cargo-lock.html
+Cargo.lock
+
+# These are backup files generated by rustfmt
+**/*.rs.bk
+
+**/temp/

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

@@ -0,0 +1,37 @@
+[package]
+name = "flowy-sdk"
+version = "0.1.0"
+edition = "2018"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]
+lib-dispatch = { path = "../lib-dispatch" }
+lib-log = { path = "../lib-log" }
+flowy-user = { path = "../flowy-user" }
+lib-infra = { path = "../lib-infra" }
+flowy-workspace = { path = "../flowy-workspace", default-features = false }
+flowy-database = { path = "../flowy-database" }
+flowy-document = { path = "../flowy-document" }
+flowy-document-infra = { path = "../flowy-document-infra" }
+lib-ws = { path = "../lib-ws" }
+backend-service = { path = "../backend-service" }
+tracing = { version = "0.1" }
+log = "0.4.14"
+futures-core = { version = "0.3", default-features = false }
+color-eyre = { version = "0.5", default-features = false }
+bytes = "1.0"
+tokio = { version = "1", features = ["rt"] }
+parking_lot = "0.11"
+
+[dev-dependencies]
+serde = { version = "1.0", features = ["derive"] }
+bincode = { version = "1.3"}
+protobuf = {version = "2.24.1"}
+claim = "0.5.0"
+tokio = { version = "1", features = ["full"]}
+futures-util = "0.3.15"
+
+[features]
+http_server = ["flowy-user/http_server", "flowy-workspace/http_server", "flowy-document/http_server"]
+use_bunyan = ["lib-log/use_bunyan"]

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

@@ -0,0 +1,104 @@
+use bytes::Bytes;
+use flowy_database::ConnectionPool;
+use flowy_document::{
+    errors::{internal_error, DocError},
+    module::DocumentUser,
+    services::ws::{DocumentWebSocket, WsDocumentManager, WsStateReceiver},
+};
+use flowy_document_infra::entities::ws::WsDocumentData;
+use flowy_user::{
+    errors::{ErrorCode, UserError},
+    services::user::UserSession,
+};
+use lib_ws::{WsMessage, WsMessageHandler, WsModule};
+use std::{convert::TryInto, path::Path, sync::Arc};
+
+pub struct DocumentDepsResolver {
+    user_session: Arc<UserSession>,
+}
+
+impl DocumentDepsResolver {
+    pub fn new(user_session: Arc<UserSession>) -> Self { Self { user_session } }
+
+    pub fn split_into(self) -> (Arc<dyn DocumentUser>, Arc<WsDocumentManager>) {
+        let user = Arc::new(DocumentUserImpl {
+            user: self.user_session.clone(),
+        });
+
+        let sender = Arc::new(WsSenderImpl {
+            user: self.user_session.clone(),
+        });
+        let ws_manager = Arc::new(WsDocumentManager::new(sender));
+        let ws_handler = Arc::new(WsDocumentReceiver {
+            inner: ws_manager.clone(),
+        });
+        self.user_session.add_ws_handler(ws_handler);
+        (user, ws_manager)
+    }
+}
+
+struct DocumentUserImpl {
+    user: Arc<UserSession>,
+}
+
+impl DocumentUserImpl {}
+
+fn map_user_error(error: UserError) -> DocError {
+    match ErrorCode::from_i32(error.code) {
+        ErrorCode::InternalError => DocError::internal().context(error.msg),
+        _ => DocError::internal().context(error),
+    }
+}
+
+impl DocumentUser for DocumentUserImpl {
+    fn user_dir(&self) -> Result<String, DocError> {
+        let dir = self.user.user_dir().map_err(|e| DocError::unauthorized().context(e))?;
+
+        let doc_dir = format!("{}/doc", dir);
+        if !Path::new(&doc_dir).exists() {
+            let _ = std::fs::create_dir_all(&doc_dir)?;
+        }
+        Ok(doc_dir)
+    }
+
+    fn user_id(&self) -> Result<String, DocError> { self.user.user_id().map_err(map_user_error) }
+
+    fn token(&self) -> Result<String, DocError> { self.user.token().map_err(map_user_error) }
+
+    fn db_pool(&self) -> Result<Arc<ConnectionPool>, DocError> { self.user.db_pool().map_err(map_user_error) }
+}
+
+struct WsSenderImpl {
+    user: Arc<UserSession>,
+}
+
+impl DocumentWebSocket for WsSenderImpl {
+    fn send(&self, data: WsDocumentData) -> Result<(), DocError> {
+        if cfg!(feature = "http_server") {
+            let bytes: Bytes = data.try_into().unwrap();
+            let msg = WsMessage {
+                module: WsModule::Doc,
+                data: bytes.to_vec(),
+            };
+            let sender = self.user.ws_controller.sender().map_err(internal_error)?;
+            sender.send_msg(msg).map_err(internal_error)?;
+        }
+
+        Ok(())
+    }
+
+    fn state_notify(&self) -> WsStateReceiver { self.user.ws_controller.state_subscribe() }
+}
+
+struct WsDocumentReceiver {
+    inner: Arc<WsDocumentManager>,
+}
+
+impl WsMessageHandler for WsDocumentReceiver {
+    fn source(&self) -> WsModule { WsModule::Doc }
+
+    fn receive_message(&self, msg: WsMessage) {
+        let data = Bytes::from(msg.data);
+        self.inner.handle_ws_data(data);
+    }
+}

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

@@ -0,0 +1,5 @@
+mod document_deps;
+mod workspace_deps;
+
+pub use document_deps::*;
+pub use workspace_deps::*;

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

@@ -0,0 +1,51 @@
+use flowy_database::ConnectionPool;
+use flowy_user::services::user::UserSession;
+use flowy_workspace::{
+    errors::WorkspaceError,
+    module::{WorkspaceDatabase, WorkspaceUser},
+};
+use std::sync::Arc;
+
+pub struct WorkspaceDepsResolver {
+    inner: Arc<Resolver>,
+}
+
+struct Resolver {
+    pub(crate) user_session: Arc<UserSession>,
+}
+
+impl WorkspaceDepsResolver {
+    pub fn new(user_session: Arc<UserSession>) -> Self {
+        Self {
+            inner: Arc::new(Resolver { user_session }),
+        }
+    }
+
+    pub fn split_into(self) -> (Arc<dyn WorkspaceUser>, Arc<dyn WorkspaceDatabase>) {
+        let user: Arc<dyn WorkspaceUser> = self.inner.clone();
+        let database: Arc<dyn WorkspaceDatabase> = self.inner.clone();
+        (user, database)
+    }
+}
+
+impl WorkspaceDatabase for Resolver {
+    fn db_pool(&self) -> Result<Arc<ConnectionPool>, WorkspaceError> {
+        self.user_session
+            .db_pool()
+            .map_err(|e| WorkspaceError::internal().context(e))
+    }
+}
+
+impl WorkspaceUser for Resolver {
+    fn user_id(&self) -> Result<String, WorkspaceError> {
+        self.user_session
+            .user_id()
+            .map_err(|e| WorkspaceError::internal().context(e))
+    }
+
+    fn token(&self) -> Result<String, WorkspaceError> {
+        self.user_session
+            .token()
+            .map_err(|e| WorkspaceError::internal().context(e))
+    }
+}

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

@@ -0,0 +1,169 @@
+mod deps_resolve;
+// mod flowy_server;
+pub mod module;
+
+use crate::deps_resolve::WorkspaceDepsResolver;
+use backend_service::config::ServerConfig;
+use flowy_document::module::FlowyDocument;
+use flowy_user::services::user::{UserSession, UserSessionBuilder, UserStatus};
+use flowy_workspace::{errors::WorkspaceError, prelude::WorkspaceController};
+use lib_dispatch::prelude::*;
+use module::mk_modules;
+pub use module::*;
+use std::sync::{
+    atomic::{AtomicBool, Ordering},
+    Arc,
+};
+use tokio::sync::broadcast;
+
+static INIT_LOG: AtomicBool = AtomicBool::new(false);
+
+#[derive(Debug, Clone)]
+pub struct FlowySDKConfig {
+    name: String,
+    root: String,
+    log_filter: String,
+    server_config: ServerConfig,
+}
+
+impl FlowySDKConfig {
+    pub fn new(root: &str, server_config: ServerConfig, name: &str) -> Self {
+        FlowySDKConfig {
+            name: name.to_owned(),
+            root: root.to_owned(),
+            log_filter: crate_log_filter(None),
+            server_config,
+        }
+    }
+
+    pub fn log_filter(mut self, filter: &str) -> Self {
+        self.log_filter = crate_log_filter(Some(filter.to_owned()));
+        self
+    }
+}
+
+fn crate_log_filter(level: Option<String>) -> String {
+    let level = level.unwrap_or(std::env::var("RUST_LOG").unwrap_or("info".to_owned()));
+    let mut filters = vec![];
+    filters.push(format!("flowy_sdk={}", level));
+    filters.push(format!("flowy_workspace={}", level));
+    filters.push(format!("flowy_user={}", level));
+    filters.push(format!("flowy_document={}", level));
+    filters.push(format!("flowy_document_infra={}", level));
+    filters.push(format!("dart_notify={}", level));
+    filters.push(format!("lib_ot={}", level));
+    filters.push(format!("lib_ws={}", level));
+    filters.push(format!("lib_infra={}", level));
+    filters.join(",")
+}
+
+#[derive(Clone)]
+pub struct FlowySDK {
+    config: FlowySDKConfig,
+    pub user_session: Arc<UserSession>,
+    pub flowy_document: Arc<FlowyDocument>,
+    pub workspace: Arc<WorkspaceController>,
+    pub dispatch: Arc<EventDispatch>,
+}
+
+impl FlowySDK {
+    pub fn new(config: FlowySDKConfig) -> Self {
+        init_log(&config);
+        init_kv(&config.root);
+        tracing::debug!("🔥 {:?}", config);
+
+        let session_cache_key = format!("{}_session_cache", &config.name);
+        let user_session = Arc::new(
+            UserSessionBuilder::new()
+                .root_dir(&config.root, &config.server_config, &session_cache_key)
+                .build(),
+        );
+        let flowy_document = mk_document_module(user_session.clone(), &config.server_config);
+        let workspace = mk_workspace(user_session.clone(), flowy_document.clone(), &config.server_config);
+        let modules = mk_modules(workspace.clone(), user_session.clone());
+        let dispatch = Arc::new(EventDispatch::construct(|| modules));
+        _init(&dispatch, user_session.clone(), workspace.clone());
+
+        Self {
+            config,
+            user_session,
+            flowy_document,
+            workspace,
+            dispatch,
+        }
+    }
+
+    pub fn dispatch(&self) -> Arc<EventDispatch> { self.dispatch.clone() }
+}
+
+fn _init(dispatch: &EventDispatch, user_session: Arc<UserSession>, workspace_controller: Arc<WorkspaceController>) {
+    let subscribe = user_session.status_subscribe();
+    dispatch.spawn(async move {
+        user_session.init();
+        _listen_user_status(subscribe, workspace_controller).await;
+    });
+}
+
+async fn _listen_user_status(
+    mut subscribe: broadcast::Receiver<UserStatus>,
+    workspace_controller: Arc<WorkspaceController>,
+) {
+    loop {
+        match subscribe.recv().await {
+            Ok(status) => {
+                let result = || async {
+                    match status {
+                        UserStatus::Login { token } => {
+                            let _ = workspace_controller.user_did_sign_in(&token).await?;
+                        },
+                        UserStatus::Logout { .. } => {
+                            workspace_controller.user_did_logout().await;
+                        },
+                        UserStatus::Expired { .. } => {
+                            workspace_controller.user_session_expired().await;
+                        },
+                        UserStatus::SignUp { profile, ret } => {
+                            let _ = workspace_controller.user_did_sign_up(&profile.token).await?;
+                            let _ = ret.send(());
+                        },
+                    }
+                    Ok::<(), WorkspaceError>(())
+                };
+
+                match result().await {
+                    Ok(_) => {},
+                    Err(e) => log::error!("{}", e),
+                }
+            },
+            Err(_) => {},
+        }
+    }
+}
+
+fn init_kv(root: &str) {
+    match lib_infra::kv::KV::init(root) {
+        Ok(_) => {},
+        Err(e) => tracing::error!("Init kv store failedL: {}", e),
+    }
+}
+
+fn init_log(config: &FlowySDKConfig) {
+    if !INIT_LOG.load(Ordering::SeqCst) {
+        INIT_LOG.store(true, Ordering::SeqCst);
+
+        let _ = lib_log::Builder::new("flowy-client", &config.root)
+            .env_filter(&config.log_filter)
+            .build();
+    }
+}
+
+fn mk_workspace(
+    user_session: Arc<UserSession>,
+    flowy_document: Arc<FlowyDocument>,
+    server_config: &ServerConfig,
+) -> Arc<WorkspaceController> {
+    let workspace_deps = WorkspaceDepsResolver::new(user_session.clone());
+    let (user, database) = workspace_deps.split_into();
+    let workspace_controller = flowy_workspace::module::mk_workspace(user, database, flowy_document, server_config);
+    workspace_controller
+}

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

@@ -0,0 +1,24 @@
+use crate::deps_resolve::DocumentDepsResolver;
+use backend_service::config::ServerConfig;
+use flowy_document::module::FlowyDocument;
+use flowy_user::services::user::UserSession;
+use flowy_workspace::prelude::WorkspaceController;
+use lib_dispatch::prelude::Module;
+use std::sync::Arc;
+
+pub fn mk_modules(workspace_controller: Arc<WorkspaceController>, user_session: Arc<UserSession>) -> Vec<Module> {
+    vec![mk_user_module(user_session), mk_workspace_module(workspace_controller)]
+}
+
+fn mk_user_module(user_session: Arc<UserSession>) -> Module { flowy_user::module::create(user_session.clone()) }
+
+fn mk_workspace_module(workspace_controller: Arc<WorkspaceController>) -> Module {
+    flowy_workspace::module::create(workspace_controller)
+}
+
+pub fn mk_document_module(user_session: Arc<UserSession>, server_config: &ServerConfig) -> Arc<FlowyDocument> {
+    let document_deps = DocumentDepsResolver::new(user_session.clone());
+    let (user, ws_manager) = document_deps.split_into();
+    let document = Arc::new(FlowyDocument::new(user, ws_manager, server_config));
+    document
+}