[PM-18046] Implement session storage (#547)

## 🎟️ Tracking

<!-- Paste the link to the Jira or GitHub issue or otherwise describe /
point to where this change is coming from. -->

## 📔 Objective

Add JS-compatible session repository implementation. I also added the
ability to switch for situations where state providers might not make
sense, for example if they will use insecure IPC to save the data,
defeating the whole point of a secure session.

## ⏰ Reminders before review

- Contributor guidelines followed
- All formatters and local linters executed and passed
- Written new unit and / or integration tests where applicable
- Protected functional changes with optionality (feature flags)
- Used internationalization (i18n) for all UI strings
- CI builds passed
- Communicated to DevOps any deployment requirements
- Updated any necessary documentation (Confluence, contributing docs) or
informed the documentation
  team

## 🦮 Reviewer guidelines

<!-- Suggested interactions but feel free to use (or not) as you desire!
-->

- 👍 (`:+1:`) or similar for great changes
- 📝 (`:memo:`) or ℹ️ (`:information_source:`) for notes or general info
- ❓ (`:question:`) for questions
- 🤔 (`:thinking:`) or 💭 (`:thought_balloon:`) for more open inquiry
that's not quite a confirmed
  issue and could potentially benefit from discussion
- 🎨 (`:art:`) for suggestions / improvements
- ❌ (`:x:`) or ⚠️ (`:warning:`) for more significant problems or
concerns needing attention
- 🌱 (`:seedling:`) or ♻️ (`:recycle:`) for future improvements or
indications of technical debt
- ⛏ (`:pick:`) for minor or nitpick changes

Author: coroiu

crates/bitwarden-ipc/src/wasm/generic_session_repository.rs

@@ -0,0 +1,78 @@
+//! Generic session repository abstraction allowing IPC clients to choose between
+//! SDK-managed (in-memory) and client-managed (JavaScript-backed) session storage.
+//!
+//! This is a workaround because wasm-bindgen does not handle generics.
+//!
+//! Use SDK-managed when state providers might not make sense, for example if they
+//! will use insecure IPC to save the data, defeating the whole point of a secure session.
+
+use std::sync::Arc;
+
+use crate::{
+    traits::{InMemorySessionRepository, SessionRepository},
+    wasm::JsSessionRepository,
+};
+
+// TODO: Change session type when implementing encryption
+type Session = ();
+
+pub enum GenericSessionRepository {
+    InMemory(Arc<InMemorySessionRepository<Session>>),
+    JsSessionRepository(Arc<JsSessionRepository>),
+}
+
+impl SessionRepository<Session> for GenericSessionRepository {
+    type GetError = String;
+    type SaveError = String;
+    type RemoveError = String;
+
+    async fn get(
+        &self,
+        endpoint: crate::endpoint::Endpoint,
+    ) -> Result<Option<Session>, Self::GetError> {
+        match self {
+            GenericSessionRepository::InMemory(repo) => repo
+                .get(endpoint)
+                .await
+                .map_err(|_| "InMemorySessionRepository::get should never fail".to_owned()),
+            GenericSessionRepository::JsSessionRepository(repo) => {
+                <JsSessionRepository as SessionRepository<Session>>::get(repo.as_ref(), endpoint)
+                    .await
+            }
+        }
+    }
+
+    async fn save(
+        &self,
+        endpoint: crate::endpoint::Endpoint,
+        session: Session,
+    ) -> Result<(), Self::SaveError> {
+        match self {
+            GenericSessionRepository::InMemory(repo) => repo
+                .save(endpoint, session)
+                .await
+                .map_err(|_| "InMemorySessionRepository::save should never fail".to_owned()),
+            GenericSessionRepository::JsSessionRepository(repo) => {
+                <JsSessionRepository as SessionRepository<Session>>::save(
+                    repo.as_ref(),
+                    endpoint,
+                    session,
+                )
+                .await
+            }
+        }
+    }
+
+    async fn remove(&self, endpoint: crate::endpoint::Endpoint) -> Result<(), Self::RemoveError> {
+        match self {
+            GenericSessionRepository::InMemory(repo) => repo
+                .remove(endpoint)
+                .await
+                .map_err(|_| "InMemorySessionRepository::remove should never fail".to_owned()),
+            GenericSessionRepository::JsSessionRepository(repo) => {
+                <JsSessionRepository as SessionRepository<Session>>::remove(repo.as_ref(), endpoint)
+                    .await
+            }
+        }
+    }
+}

crates/bitwarden-ipc/src/wasm/ipc_client.rs

@@ -9,6 +9,10 @@ use crate::{
     ipc_client::{IpcClientSubscription, ReceiveError, SubscribeError},
     message::{IncomingMessage, OutgoingMessage},
     traits::{InMemorySessionRepository, NoEncryptionCryptoProvider},
+    wasm::{
+        JsSessionRepository, RawJsSessionRepository,
+        generic_session_repository::GenericSessionRepository,
+    },
 };
 
 /// JavaScript wrapper around the IPC client. For more information, see the
@@ -21,12 +25,7 @@ pub struct JsIpcClient {
     /// send typed messages, etc. For examples see
     /// [wasm::ipc_register_discover_handler](crate::wasm::ipc_register_discover_handler).
     pub client: Arc<
-        IpcClient<
-            NoEncryptionCryptoProvider,
-            JsCommunicationBackend,
-            // TODO: Change session provider to a JS-implemented one
-            InMemorySessionRepository<()>,
-        >,
+        IpcClient<NoEncryptionCryptoProvider, JsCommunicationBackend, GenericSessionRepository>,
     >,
 }
 
@@ -51,14 +50,36 @@ impl JsIpcClientSubscription {
 
 #[wasm_bindgen(js_class = IpcClient)]
 impl JsIpcClient {
-    #[allow(missing_docs)]
-    #[wasm_bindgen(constructor)]
-    pub fn new(communication_provider: &JsCommunicationBackend) -> JsIpcClient {
+    /// Create a new `IpcClient` instance with an in-memory session repository for saving
+    /// sessions within the SDK.
+    #[wasm_bindgen(js_name = newWithSdkInMemorySessions)]
+    pub fn new_with_sdk_in_memory_sessions(
+        communication_provider: &JsCommunicationBackend,
+    ) -> JsIpcClient {
+        JsIpcClient {
+            client: IpcClient::new(
+                NoEncryptionCryptoProvider,
+                communication_provider.clone(),
+                GenericSessionRepository::InMemory(Arc::new(InMemorySessionRepository::new(
+                    HashMap::new(),
+                ))),
+            ),
+        }
+    }
+    /// Create a new `IpcClient` instance with a client-managed session repository for saving
+    /// sessions using State Provider.
+    #[wasm_bindgen(js_name = newWithClientManagedSessions)]
+    pub fn new_with_client_managed_sessions(
+        communication_provider: &JsCommunicationBackend,
+        session_repository: RawJsSessionRepository,
+    ) -> JsIpcClient {
         JsIpcClient {
             client: IpcClient::new(
                 NoEncryptionCryptoProvider,
                 communication_provider.clone(),
-                InMemorySessionRepository::new(HashMap::new()),
+                GenericSessionRepository::JsSessionRepository(Arc::new(JsSessionRepository::new(
+                    session_repository,
+                ))),
             ),
         }
     }

crates/bitwarden-ipc/src/wasm/js_session_repository.rs

@@ -0,0 +1,101 @@
+use bitwarden_threading::ThreadBoundRunner;
+use serde::{Serialize, de::DeserializeOwned};
+use tsify::serde_wasm_bindgen;
+use wasm_bindgen::prelude::*;
+
+use crate::{endpoint::Endpoint, traits::SessionRepository};
+
+#[wasm_bindgen(typescript_custom_section)]
+const TS_CUSTOM_TYPES: &'static str = r#"
+export interface IpcSessionRepository {
+    get(endpoint: Endpoint): Promise<any | undefined>;
+    save(endpoint: Endpoint, session: any): Promise<void>;
+    remove(endpoint: Endpoint): Promise<void>;
+}
+"#;
+
+#[wasm_bindgen]
+extern "C" {
+    /// JavaScript interface for handling outgoing messages from the IPC framework.
+    #[wasm_bindgen(js_name = IpcSessionRepository, typescript_type = "IpcSessionRepository")]
+    pub type RawJsSessionRepository;
+
+    /// Used by the IPC framework to get a session for a specific endpoint.
+    #[wasm_bindgen(catch, method, structural)]
+    pub async fn get(this: &RawJsSessionRepository, endpoint: Endpoint)
+    -> Result<JsValue, JsValue>;
+
+    /// Used by the IPC framework to save a session for a specific endpoint.
+    #[wasm_bindgen(catch, method, structural)]
+    pub async fn save(
+        this: &RawJsSessionRepository,
+        endpoint: Endpoint,
+        session: JsValue,
+    ) -> Result<(), JsValue>;
+
+    /// Used by the IPC framework to remove a session for a specific endpoint.
+    #[wasm_bindgen(catch, method, structural)]
+    pub async fn remove(this: &RawJsSessionRepository, endpoint: Endpoint) -> Result<(), JsValue>;
+}
+
+/// Thread safe JavaScript implementation of the `SessionRepository` trait for IPC sessions.
+pub struct JsSessionRepository(ThreadBoundRunner<RawJsSessionRepository>);
+
+impl JsSessionRepository {
+    /// Creates a new `JsSessionRepository` instance wrapping the raw JavaScript repository.
+    pub fn new(repository: RawJsSessionRepository) -> Self {
+        Self(ThreadBoundRunner::new(repository))
+    }
+}
+
+impl Clone for JsSessionRepository {
+    fn clone(&self) -> Self {
+        Self(self.0.clone())
+    }
+}
+
+impl<Session> SessionRepository<Session> for JsSessionRepository
+where
+    Session: Serialize + DeserializeOwned + Send + Sync + 'static,
+{
+    type GetError = String;
+    type SaveError = String;
+    type RemoveError = String;
+
+    async fn get(&self, endpoint: Endpoint) -> Result<Option<Session>, Self::GetError> {
+        self.0
+            .run_in_thread(move |repo| async move {
+                let js_value = repo.get(endpoint).await.map_err(|e| format!("{e:?}"))?;
+                if js_value.is_undefined() || js_value.is_null() {
+                    return Ok(None);
+                }
+
+                Ok(Some(
+                    serde_wasm_bindgen::from_value(js_value).map_err(|e| e.to_string())?,
+                ))
+            })
+            .await
+            .map_err(|e| e.to_string())?
+    }
+
+    async fn save(&self, endpoint: Endpoint, session: Session) -> Result<(), Self::SaveError> {
+        self.0
+            .run_in_thread(move |repo| async move {
+                let js_value = serde_wasm_bindgen::to_value(&session).map_err(|e| e.to_string())?;
+                repo.save(endpoint, js_value)
+                    .await
+                    .map_err(|e| format!("{e:?}"))
+            })
+            .await
+            .map_err(|e| e.to_string())?
+    }
+
+    async fn remove(&self, endpoint: Endpoint) -> Result<(), Self::RemoveError> {
+        self.0
+            .run_in_thread(move |repo| async move {
+                repo.remove(endpoint).await.map_err(|e| format!("{e:?}"))
+            })
+            .await
+            .map_err(|e| e.to_string())?
+    }
+}

crates/bitwarden-ipc/src/wasm/mod.rs

@@ -1,9 +1,12 @@
 mod communication_backend;
 mod discover;
+mod generic_session_repository;
 mod ipc_client;
+mod js_session_repository;
 mod message;
 
 // Re-export types to make sure wasm_bindgen picks them up
 pub use communication_backend::*;
 pub use discover::*;
 pub use ipc_client::*;
+pub use js_session_repository::*;