chore: add some more docs

Author: coroiu

crates/bitwarden-ipc/src/ipc_client.rs

@@ -11,7 +11,9 @@ use crate::{
     traits::{CommunicationBackend, CryptoProvider, SessionRepository},
 };
 
-#[allow(missing_docs)]
+/// An IPC client that handles communication between different components and clients.
+/// It uses a crypto provider to encrypt and decrypt messages, a communication backend to send and
+/// receive messages, and a session repository to persist sessions.
 pub struct IpcClient<Crypto, Com, Ses>
 where
     Crypto: CryptoProvider<Com, Ses>,
@@ -96,7 +98,7 @@ where
     Com: CommunicationBackend,
     Ses: SessionRepository<Crypto::Session>,
 {
-    #[allow(missing_docs)]
+    /// Create a new IPC client with the provided crypto provider, communication backend, and session repository.
     pub fn new(crypto: Crypto, communication: Com, sessions: Ses) -> Arc<Self> {
         Arc::new(Self {
             crypto,
@@ -108,7 +110,11 @@ where
         })
     }
 
-    #[allow(missing_docs)]
+    /// Start the IPC client, which will begin listening for incoming messages and processing them.
+    /// This will be done in a separate task, allowing the client to receive messages asynchronously.
+    /// The client will stop automatically if an error occurs during message processing or if the cancellation token is triggered.
+    ///
+    /// Note: The client can and will send messages in the background while it is running, even if no active subscriptions are present.
     pub async fn start(self: &Arc<Self>) {
         let cancellation_token = CancellationToken::new();
         self.cancellation_token
@@ -156,14 +162,14 @@ where
         wasm_bindgen_futures::spawn_local(future);
     }
 
-    #[allow(missing_docs)]
+    /// Check if the IPC client task is currently running.
     pub async fn is_running(self: &Arc<Self>) -> bool {
         let has_incoming = self.incoming.read().await.is_some();
         let has_cancellation_token = self.cancellation_token.read().await.is_some();
         has_incoming && has_cancellation_token
     }
 
-    #[allow(missing_docs)]
+    /// Stop the IPC client task. This will stop listening for incoming messages.
     pub async fn stop(self: &Arc<Self>) {
         let mut incoming = self.incoming.write().await;
         let _ = incoming.take();

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

@@ -32,23 +32,23 @@ export interface IpcCommunicationBackendSender {
 
 #[wasm_bindgen]
 extern "C" {
-    #[allow(missing_docs)]
+    /// JavaScript interface for handling outgoing messages from the IPC framework.
     #[wasm_bindgen(js_name = IpcCommunicationBackendSender, typescript_type = "IpcCommunicationBackendSender")]
     pub type JsCommunicationBackendSender;
 
-    #[allow(missing_docs)]
+    /// Used by the IPC framework to send an outgoing message.
     #[wasm_bindgen(catch, method, structural)]
     pub async fn send(
         this: &JsCommunicationBackendSender,
         message: OutgoingMessage,
     ) -> Result<(), JsValue>;
 
-    #[allow(missing_docs)]
+    /// Used by JavaScript to provide an incoming message to the IPC framework.
     #[wasm_bindgen(catch, method, structural)]
     pub async fn receive(this: &JsCommunicationBackendSender) -> Result<JsValue, JsValue>;
 }
 
-#[allow(missing_docs)]
+/// JavaScript implementation of the `CommunicationBackend` trait for IPC communication.
 #[wasm_bindgen(js_name = IpcCommunicationBackend)]
 pub struct JsCommunicationBackend {
     sender: Arc<ThreadBoundRunner<JsCommunicationBackendSender>>,
@@ -68,7 +68,7 @@ impl Clone for JsCommunicationBackend {
 
 #[wasm_bindgen(js_class = IpcCommunicationBackend)]
 impl JsCommunicationBackend {
-    #[allow(missing_docs)]
+    /// Creates a new instance of the JavaScript communication backend.
     #[wasm_bindgen(constructor)]
     pub fn new(sender: JsCommunicationBackendSender) -> Self {
         let (receive_tx, receive_rx) = tokio::sync::broadcast::channel(20);
@@ -79,8 +79,8 @@ impl JsCommunicationBackend {
         }
     }
 
-    /// JavaScript function to provide a received message to the backend/IPC framework.
-    pub fn deliver_message(&self, message: IncomingMessage) -> Result<(), JsValue> {
+    /// Used by JavaScript to provide an incoming message to the IPC framework.
+    pub fn receive(&self, message: IncomingMessage) -> Result<(), JsValue> {
         self.receive_tx
             .send(message)
             .map_err(|e| ChannelError(e.to_string()))?;

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

@@ -11,7 +11,8 @@ use crate::{
     IpcClient,
 };
 
-#[allow(missing_docs)]
+/// JavaScript wrapper around the IPC client. For more information, see the
+/// [IpcClient] documentation.
 #[wasm_bindgen(js_name = IpcClient)]
 pub struct JsIpcClient {
     // TODO: Change session provider to a JS-implemented one
@@ -24,15 +25,16 @@ pub struct JsIpcClient {
     >,
 }
 
-#[allow(missing_docs)]
+/// JavaScript wrapper around the IPC client subscription. For more information, see the
+/// [IpcClientSubscription] documentation.
 #[wasm_bindgen(js_name = IpcClientSubscription)]
 pub struct JsIpcClientSubscription {
     subscription: IpcClientSubscription,
 }
 
-#[allow(missing_docs)]
 #[wasm_bindgen(js_class = IpcClientSubscription)]
 impl JsIpcClientSubscription {
+    #[allow(missing_docs)]
     pub async fn receive(
         &mut self,
         abort_signal: Option<AbortSignal>,