feat(ffi): Add IndexedDB and in-memory session stores support.

This patch introduces the `sqlite` and `indexeddb` feature flag,
enabling the use of SQLite or IndexedDB for the session store. This
patch also introduces the ability to use non-persistent, in-memory
session store.

The new `ClientBuilder::session_store_in_memory`,
`ClientBuilder::session_store_with_sqlite` and
`ClientBuilder::session_store_with_indexeddb` methods are
introduced to configure the session store. This patch adds new
`SqliteSessionStoreBuilder` and `IndexedDbSessionStoreBuilder`
structure.

Author: Hywan

bindings/matrix-sdk-ffi/Cargo.toml

@@ -25,7 +25,12 @@ crate-type = [
 
 [features]
 default = ["bundled-sqlite", "unstable-msc4274", "experimental-element-recent-emojis"]
-bundled-sqlite = ["matrix-sdk/bundled-sqlite"]
+# Use SQLite for the session storage.
+sqlite = ["matrix-sdk/sqlite"]
+# Use an embedded version of SQLite.
+bundled-sqlite = ["sqlite", "matrix-sdk/bundled-sqlite"]
+# Use IndexedDB for the session storage.
+indexeddb = ["matrix-sdk/indexeddb"]
 unstable-msc4274 = ["matrix-sdk-ui/unstable-msc4274"]
 # Required when targeting a Javascript environment, like Wasm in a browser.
 js = ["matrix-sdk-ui/js"]
@@ -51,7 +56,6 @@ matrix-sdk = { workspace = true, features = [
     "experimental-widgets",
     "markdown",
     "socks",
-    "sqlite",
     "uniffi",
 ] }
 matrix-sdk-base.workspace = true

bindings/matrix-sdk-ffi/src/client.rs

@@ -10,6 +10,8 @@ use anyhow::{anyhow, Context as _};
 use futures_util::pin_mut;
 #[cfg(not(target_family = "wasm"))]
 use matrix_sdk::media::MediaFileHandle as SdkMediaFileHandle;
+#[cfg(feature = "sqlite")]
+use matrix_sdk::STATE_STORE_DATABASE_NAME;
 use matrix_sdk::{
     authentication::oauth::{
         AccountManagementActionFull, ClientId, OAuthAuthorizationData, OAuthSession,
@@ -39,7 +41,6 @@ use matrix_sdk::{
     sliding_sync::Version as SdkSlidingSyncVersion,
     store::RoomLoadSettings as SdkRoomLoadSettings,
     Account, AuthApi, AuthSession, Client as MatrixClient, Error, SessionChange, SessionTokens,
-    STATE_STORE_DATABASE_NAME,
 };
 use matrix_sdk_common::{stream::StreamExt, SendOutsideWasm, SyncOutsideWasm};
 use matrix_sdk_ui::{
@@ -242,13 +243,18 @@ impl From<matrix_sdk::TransmissionProgress> for TransmissionProgress {
 #[derive(uniffi::Object)]
 pub struct Client {
     pub(crate) inner: AsyncRuntimeDropped<MatrixClient>,
+
     delegate: OnceLock<Arc<dyn ClientDelegate>>,
+
     pub(crate) utd_hook_manager: OnceLock<Arc<UtdHookManager>>,
+
     session_verification_controller:
         Arc<tokio::sync::RwLock<Option<SessionVerificationController>>>,
+
     /// The path to the directory where the state store and the crypto store are
-    /// located, if the `Client` instance has been built with a SQLite store
-    /// backend.
+    /// located, if the `Client` instance has been built with a store (either
+    /// SQLite or IndexedDB).
+    #[cfg_attr(not(feature = "sqlite"), allow(unused))]
     store_path: Option<PathBuf>,
 }
 
@@ -1597,6 +1603,7 @@ impl Client {
             self.inner.event_cache().clear_all_rooms().await?;
 
             // Delete the state store file, if it exists.
+            #[cfg(feature = "sqlite")]
             if let Some(store_path) = &self.store_path {
                 debug!("Removing the state store: {}", store_path.display());
 

bindings/matrix-sdk-ffi/src/client_builder.rs

@@ -1,4 +1,4 @@
-use std::{fs, num::NonZeroUsize, path::Path, sync::Arc, time::Duration};
+use std::{num::NonZeroUsize, sync::Arc, time::Duration};
 
 #[cfg(not(target_family = "wasm"))]
 use matrix_sdk::reqwest::Certificate;
@@ -11,15 +11,21 @@ use matrix_sdk::{
         VersionBuilderError,
     },
     Client as MatrixClient, ClientBuildError as MatrixClientBuildError, HttpError, IdParseError,
-    RumaApiError, SqliteStoreConfig, ThreadingSupport,
+    RumaApiError, ThreadingSupport,
 };
 use matrix_sdk_base::crypto::{CollectStrategy, DecryptionSettings, TrustRequirement};
 use ruma::api::error::{DeserializationError, FromHttpResponseError};
 use tracing::debug;
-use zeroize::Zeroizing;
 
 use super::client::Client;
-use crate::{client::ClientSessionDelegate, error::ClientError, helpers::unwrap_or_clone_arc};
+#[cfg(any(feature = "sqlite", feature = "indexeddb"))]
+use crate::session_store;
+use crate::{
+    client::ClientSessionDelegate,
+    error::ClientError,
+    helpers::unwrap_or_clone_arc,
+    session_store::{SessionStoreBuilder, SessionStoreResult},
+};
 
 /// A list of bytes containing a certificate in DER or PEM form.
 pub type CertificateBytes = Vec<u8>;
@@ -100,11 +106,7 @@ impl From<ClientError> for ClientBuildError {
 
 #[derive(Clone, uniffi::Object)]
 pub struct ClientBuilder {
-    session_paths: Option<SessionPaths>,
-    session_passphrase: Zeroizing<Option<String>>,
-    session_pool_max_size: Option<usize>,
-    session_cache_size: Option<u32>,
-    session_journal_size_limit: Option<u32>,
+    session_store: Option<SessionStoreBuilder>,
     system_is_memory_constrained: bool,
     username: Option<String>,
     homeserver_cfg: Option<HomeserverConfig>,
@@ -143,11 +145,7 @@ impl ClientBuilder {
     #[uniffi::constructor]
     pub fn new() -> Arc<Self> {
         Arc::new(Self {
-            session_paths: None,
-            session_passphrase: Zeroizing::new(None),
-            session_pool_max_size: None,
-            session_cache_size: None,
-            session_journal_size_limit: None,
+            session_store: None,
             system_is_memory_constrained: false,
             username: None,
             homeserver_cfg: None,
@@ -201,73 +199,6 @@ impl ClientBuilder {
         Arc::new(builder)
     }
 
-    /// Sets the paths that the client will use to store its data and caches.
-    /// Both paths **must** be unique per session as the SDK stores aren't
-    /// capable of handling multiple users, however it is valid to use the
-    /// same path for both stores on a single session.
-    ///
-    /// Leaving this unset tells the client to use an in-memory data store.
-    pub fn session_paths(self: Arc<Self>, data_path: String, cache_path: String) -> Arc<Self> {
-        let mut builder = unwrap_or_clone_arc(self);
-        builder.session_paths = Some(SessionPaths { data_path, cache_path });
-        Arc::new(builder)
-    }
-
-    /// Set the passphrase for the stores given to
-    /// [`ClientBuilder::session_paths`].
-    pub fn session_passphrase(self: Arc<Self>, passphrase: Option<String>) -> Arc<Self> {
-        let mut builder = unwrap_or_clone_arc(self);
-        builder.session_passphrase = Zeroizing::new(passphrase);
-        Arc::new(builder)
-    }
-
-    /// Set the pool max size for the SQLite stores given to
-    /// [`ClientBuilder::session_paths`].
-    ///
-    /// Each store exposes an async pool of connections. This method controls
-    /// the size of the pool. The larger the pool is, the more memory is
-    /// consumed, but also the more the app is reactive because it doesn't need
-    /// to wait on a pool to be available to run queries.
-    ///
-    /// See [`SqliteStoreConfig::pool_max_size`] to learn more.
-    pub fn session_pool_max_size(self: Arc<Self>, pool_max_size: Option<u32>) -> Arc<Self> {
-        let mut builder = unwrap_or_clone_arc(self);
-        builder.session_pool_max_size = pool_max_size
-            .map(|size| size.try_into().expect("`pool_max_size` is too large to fit in `usize`"));
-        Arc::new(builder)
-    }
-
-    /// Set the cache size for the SQLite stores given to
-    /// [`ClientBuilder::session_paths`].
-    ///
-    /// Each store exposes a SQLite connection. This method controls the cache
-    /// size, in **bytes (!)**.
-    ///
-    /// The cache represents data SQLite holds in memory at once per open
-    /// database file. The default cache implementation does not allocate the
-    /// full amount of cache memory all at once. Cache memory is allocated
-    /// in smaller chunks on an as-needed basis.
-    ///
-    /// See [`SqliteStoreConfig::cache_size`] to learn more.
-    pub fn session_cache_size(self: Arc<Self>, cache_size: Option<u32>) -> Arc<Self> {
-        let mut builder = unwrap_or_clone_arc(self);
-        builder.session_cache_size = cache_size;
-        Arc::new(builder)
-    }
-
-    /// Set the size limit for the SQLite WAL files of stores given to
-    /// [`ClientBuilder::session_paths`].
-    ///
-    /// Each store uses the WAL journal mode. This method controls the size
-    /// limit of the WAL files, in **bytes (!)**.
-    ///
-    /// See [`SqliteStoreConfig::journal_size_limit`] to learn more.
-    pub fn session_journal_size_limit(self: Arc<Self>, limit: Option<u32>) -> Arc<Self> {
-        let mut builder = unwrap_or_clone_arc(self);
-        builder.session_journal_size_limit = limit;
-        Arc::new(builder)
-    }
-
     /// Tell the client that the system is memory constrained, like in a push
     /// notification process for example.
     ///
@@ -404,6 +335,13 @@ impl ClientBuilder {
         Arc::new(builder)
     }
 
+    /// Use in-memory session storage.
+    pub fn session_store_in_memory(self: Arc<Self>) -> Arc<Self> {
+        let mut builder = unwrap_or_clone_arc(self);
+        builder.session_store = Some(SessionStoreBuilder::InMemory);
+        Arc::new(builder)
+    }
+
     pub async fn build(self: Arc<Self>) -> Result<Arc<Client>, ClientBuildError> {
         let builder = unwrap_or_clone_arc(self);
         let mut inner_builder = MatrixClient::builder();
@@ -413,48 +351,26 @@ impl ClientBuilder {
                 inner_builder.cross_process_store_locks_holder_name(holder_name.clone());
         }
 
-        let store_path = if let Some(session_paths) = &builder.session_paths {
-            // This is the path where both the state store and the crypto store will live.
-            let data_path = Path::new(&session_paths.data_path);
-            // This is the path where the event cache store will live.
-            let cache_path = Path::new(&session_paths.cache_path);
+        let session_store_path = if let Some(session_store) = &builder.session_store {
+            match session_store.build()? {
+                #[cfg(feature = "sqlite")]
+                SessionStoreResult::Sqlite { config, cache_path, store_path: data_path } => {
+                    inner_builder = inner_builder
+                        .sqlite_store_with_config_and_cache_path(config, Some(cache_path));
 
-            debug!(
-                data_path = %data_path.to_string_lossy(),
-                event_cache_path = %cache_path.to_string_lossy(),
-                "Creating directories for data (state and crypto) and cache stores.",
-            );
-
-            fs::create_dir_all(data_path)?;
-            fs::create_dir_all(cache_path)?;
-
-            let mut sqlite_store_config = if builder.system_is_memory_constrained {
-                SqliteStoreConfig::with_low_memory_config(data_path)
-            } else {
-                SqliteStoreConfig::new(data_path)
-            };
-
-            sqlite_store_config =
-                sqlite_store_config.passphrase(builder.session_passphrase.as_deref());
-
-            if let Some(size) = builder.session_pool_max_size {
-                sqlite_store_config = sqlite_store_config.pool_max_size(size);
-            }
+                    Some(data_path)
+                }
+                #[cfg(feature = "indexeddb")]
+                SessionStoreResult::IndexedDb { name, passphrase } => {
+                    inner_builder = inner_builder.indexeddb_store(&name, passphrase.as_deref());
 
-            if let Some(size) = builder.session_cache_size {
-                sqlite_store_config = sqlite_store_config.cache_size(size);
-            }
+                    None
+                }
 
-            if let Some(limit) = builder.session_journal_size_limit {
-                sqlite_store_config = sqlite_store_config.journal_size_limit(limit);
+                SessionStoreResult::InMemory => None,
             }
-
-            inner_builder = inner_builder
-                .sqlite_store_with_config_and_cache_path(sqlite_store_config, Some(cache_path));
-
-            Some(data_path.to_owned())
         } else {
-            debug!("Not using a store path.");
+            debug!("Not using a session store");
             None
         };
 
@@ -594,13 +510,41 @@ impl ClientBuilder {
                 sdk_client,
                 builder.enable_oidc_refresh_lock,
                 builder.session_delegate,
-                store_path,
+                session_store_path,
             )
             .await?,
         ))
     }
 }
 
+#[cfg(feature = "sqlite")]
+#[matrix_sdk_ffi_macros::export]
+impl ClientBuilder {
+    /// Use SQLite as the session storage.
+    pub fn session_store_with_sqlite(
+        self: Arc<Self>,
+        config: Arc<session_store::SqliteSessionStoreBuilder>,
+    ) -> Arc<Self> {
+        let mut builder = unwrap_or_clone_arc(self);
+        builder.session_store = Some(SessionStoreBuilder::Sqlite(unwrap_or_clone_arc(config)));
+        Arc::new(builder)
+    }
+}
+
+#[cfg(feature = "indexeddb")]
+#[matrix_sdk_ffi_macros::export]
+impl ClientBuilder {
+    /// Use IndexedDB as the session storage.
+    pub fn session_store_with_indexeddb(
+        self: Arc<Self>,
+        config: Arc<session_store::IndexedDbSessionStoreBuilder>,
+    ) -> Arc<Self> {
+        let mut builder = unwrap_or_clone_arc(self);
+        builder.session_store = Some(SessionStoreBuilder::IndexedDb(unwrap_or_clone_arc(config)));
+        Arc::new(builder)
+    }
+}
+
 #[cfg(not(target_family = "wasm"))]
 #[matrix_sdk_ffi_macros::export]
 impl ClientBuilder {
@@ -642,18 +586,8 @@ impl ClientBuilder {
     }
 }
 
-/// The store paths the client will use when built.
-#[derive(Clone)]
-struct SessionPaths {
-    /// The path that the client will use to store its data.
-    data_path: String,
-    /// The path that the client will use to store its caches. This path can be
-    /// the same as the data path if you prefer to keep everything in one place.
-    cache_path: String,
-}
-
-#[derive(Clone, uniffi::Record)]
 /// The config to use for HTTP requests by default in this client.
+#[derive(Clone, uniffi::Record)]
 pub struct RequestConfig {
     /// Max number of retries.
     retry_limit: Option<u64>,

bindings/matrix-sdk-ffi/src/lib.rs

@@ -24,6 +24,7 @@ mod room_member;
 mod room_preview;
 mod ruma;
 mod runtime;
+mod session_store;
 mod session_verification;
 mod spaces;
 mod sync_service;