Bring projects, wikis, and teams together with AI. AppFlowy is the AI collaborative workspace where you achieve more without losing control of your data. The leading open source Notion alternative.
Dart blogconfluence-alternativecontent-managementcontent-servicesdocumentationflutternote-takingnotion-alternativeproject-managementtask-managementteam-collaborationwiki
use client_api::ws::ConnectState;
use client_api::ws::WSConnectStateReceiver;
use client_api::ws::WebSocketChannel;
use flowy_search_pub::cloud::SearchCloudService;
use std::sync::{Arc, Weak};
use anyhow::Error;
use arc_swap::ArcSwapOption;
use client_api::collab_sync::ServerCollabMessage;
use collab::entity::EncodedCollab;
use collab_entity::CollabType;
use flowy_ai_pub::cloud::ChatCloudService;
use flowy_ai_pub::entities::UnindexedCollab;
use flowy_database_pub::cloud::{DatabaseAIService, DatabaseCloudService};
use flowy_document_pub::cloud::DocumentCloudService;
use flowy_error::FlowyResult;
use flowy_folder_pub::cloud::FolderCloudService;
use flowy_search_pub::tantivy_state::DocumentTantivyState;
use flowy_storage_pub::cloud::StorageCloudService;
use flowy_user_pub::cloud::UserCloudService;
use flowy_user_pub::entities::UserTokenState;
use lib_infra::async_trait::async_trait;
use tokio::sync::RwLock;
use tokio_stream::wrappers::WatchStream;
use uuid::Uuid;
#[async_trait]
pub trait EmbeddingWriter: Send + Sync + 'static {
async fn index_encoded_collab(
&self,
workspace_id: Uuid,
object_id: Uuid,
data: EncodedCollab,
collab_type: CollabType,
) -> FlowyResult<()>;
async fn index_unindexed_collab(&self, data: UnindexedCollab) -> FlowyResult<()>;
}
pub trait AppFlowyEncryption: Send + Sync + 'static {
fn get_secret(&self) -> Option<String>;
fn set_secret(&self, secret: String);
}
impl<T> AppFlowyEncryption for Arc<T>
where
T: AppFlowyEncryption,
{
fn get_secret(&self) -> Option<String> {
(**self).get_secret()
}
fn set_secret(&self, secret: String) {
(**self).set_secret(secret)
}
}
/// `AppFlowyServer` trait defines a collection of services that offer cloud-based interactions
/// and functionalities in AppFlowy. The methods provided ensure efficient, asynchronous operations
/// for managing and accessing user data, folders, collaborative objects, and documents in a cloud environment.
#[async_trait]
pub trait AppFlowyServer: Send + Sync + 'static {
fn set_token(&self, _token: &str) -> Result<(), Error>;
async fn set_tanvity_state(&self, state: Option<Weak<RwLock<DocumentTantivyState>>>);
fn set_ai_model(&self, _ai_model: &str) -> Result<(), Error> {
Ok(())
}
fn subscribe_token_state(&self) -> Option<WatchStream<UserTokenState>> {
None
}
/// Enables or disables server sync.
///
/// # Arguments
///
/// * `_enable` - A boolean to toggle the server synchronization.
fn set_enable_sync(&self, _uid: i64, _enable: bool) {}
/// Sets the network reachability status.
///
/// # Arguments
/// * `reachable`: A boolean indicating whether the network is reachable.
fn set_network_reachable(&self, _reachable: bool) {}
/// Provides access to cloud-based user management functionalities. This includes operations
/// such as user registration, authentication, profile management, and handling of user workspaces.
/// The interface also offers methods for managing collaborative objects, subscribing to user updates,
/// and receiving real-time events.
///
/// # Returns
///
/// An `Arc` wrapping the `UserCloudService` interface.
fn user_service(&self) -> Arc<dyn UserCloudService>;
/// Provides a service for managing workspaces and folders in a cloud environment. This includes
/// functionalities to create workspaces, and fetch data, snapshots, and updates related to specific folders.
///
/// # Returns
///
/// An `Arc` wrapping the `FolderCloudService` interface.
fn folder_service(&self) -> Arc<dyn FolderCloudService>;
/// Offers a set of operations for interacting with collaborative objects within a cloud database.
/// This includes functionalities such as retrieval of updates for specific objects, batch fetching,
/// and obtaining snapshots.
///
/// # Returns
///
/// An `Arc` wrapping the `DatabaseCloudService` interface.
fn database_service(&self) -> Arc<dyn DatabaseCloudService>;
fn database_ai_service(&self) -> Option<Arc<dyn DatabaseAIService>>;
/// Facilitates cloud-based document management. This service offers operations for updating documents,
/// fetching snapshots, and accessing primary document data in an asynchronous manner.
///
/// # Returns
///
/// An `Arc` wrapping the `DocumentCloudService` interface.
fn document_service(&self) -> Arc<dyn DocumentCloudService>;
fn chat_service(&self) -> Arc<dyn ChatCloudService>;
/// Bridge for the Cloud AI Search features
///
async fn search_service(&self) -> Option<Arc<dyn SearchCloudService>>;
fn subscribe_ws_state(&self) -> Option<WSConnectStateReceiver> {
None
}
fn get_ws_state(&self) -> ConnectState {
ConnectState::Lost
}
#[allow(clippy::type_complexity)]
fn collab_ws_channel(
&self,
_object_id: &str,
) -> Result<
Option<(
Arc<WebSocketChannel<ServerCollabMessage>>,
WSConnectStateReceiver,
bool,
)>,
anyhow::Error,
> {
Ok(None)
}
fn file_storage(&self) -> Option<Arc<dyn StorageCloudService>>;
}
pub struct EncryptionImpl {
secret: ArcSwapOption<String>,
}
impl EncryptionImpl {
pub fn new(secret: Option<String>) -> Self {
Self {
secret: ArcSwapOption::from(secret.map(Arc::new)),
}
}
}
impl AppFlowyEncryption for EncryptionImpl {
fn get_secret(&self) -> Option<String> {
self.secret.load().as_ref().map(|s| s.to_string())
}
fn set_secret(&self, secret: String) {
self.secret.store(Some(secret.into()));
}
}