[PM-19966] Remove subclient lifetimes (#198)

## 🎟️ Tracking

https://bitwarden.atlassian.net/browse/PM-19966

## 📔 Objective

The subclient lifetimes have been a pain point that cause us to need to
have create our duplicate copies of the structs for WASM and Uniffi that
don't deal with them.

If instead of doing that we wrap the `Client`s `InternalClient` in
`Arc`, we can just cheaply clone the `Arc` and remove all the lifetimes
from the subclients. This opens up the posibility of using the same API
for Rust/WASM/UniFFI in the future, and also simplifies the bindings a
bit in the short term.

This does have the negative that each subclient access requires an
atomic operation clone, but that's negligible for our usecases. (And we
were already doing basically the same thing for Uniffi and WASM anyway)

## ⏰ 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: dani-garcia

bitwarden_license/bitwarden-sm/src/client_projects.rs

@@ -9,57 +9,57 @@ use crate::{
     },
 };
 
-pub struct ClientProjects<'a> {
-    pub client: &'a Client,
+pub struct ClientProjects {
+    pub client: Client,
 }
 
-impl<'a> ClientProjects<'a> {
-    pub fn new(client: &'a Client) -> Self {
+impl ClientProjects {
+    pub fn new(client: Client) -> Self {
         Self { client }
     }
 
     pub async fn get(
         &self,
         input: &ProjectGetRequest,
     ) -> Result<ProjectResponse, SecretsManagerError> {
-        get_project(self.client, input).await
+        get_project(&self.client, input).await
     }
 
     pub async fn create(
         &self,
         input: &ProjectCreateRequest,
     ) -> Result<ProjectResponse, SecretsManagerError> {
-        create_project(self.client, input).await
+        create_project(&self.client, input).await
     }
 
     pub async fn list(
         &self,
         input: &ProjectsListRequest,
     ) -> Result<ProjectsResponse, SecretsManagerError> {
-        list_projects(self.client, input).await
+        list_projects(&self.client, input).await
     }
 
     pub async fn update(
         &self,
         input: &ProjectPutRequest,
     ) -> Result<ProjectResponse, SecretsManagerError> {
-        update_project(self.client, input).await
+        update_project(&self.client, input).await
     }
 
     pub async fn delete(
         &self,
         input: ProjectsDeleteRequest,
     ) -> Result<ProjectsDeleteResponse, SecretsManagerError> {
-        delete_projects(self.client, input).await
+        delete_projects(&self.client, input).await
     }
 }
 
-pub trait ClientProjectsExt<'a> {
-    fn projects(&'a self) -> ClientProjects<'a>;
+pub trait ClientProjectsExt {
+    fn projects(&self) -> ClientProjects;
 }
 
-impl<'a> ClientProjectsExt<'a> for Client {
-    fn projects(&'a self) -> ClientProjects<'a> {
-        ClientProjects::new(self)
+impl ClientProjectsExt for Client {
+    fn projects(&self) -> ClientProjects {
+        ClientProjects::new(self.clone())
     }
 }

bitwarden_license/bitwarden-sm/src/client_secrets.rs

@@ -12,78 +12,78 @@ use crate::{
     },
 };
 
-pub struct ClientSecrets<'a> {
-    client: &'a Client,
+pub struct ClientSecrets {
+    client: Client,
 }
 
-impl<'a> ClientSecrets<'a> {
-    pub fn new(client: &'a Client) -> Self {
+impl ClientSecrets {
+    pub fn new(client: Client) -> Self {
         Self { client }
     }
 
     pub async fn get(
         &self,
         input: &SecretGetRequest,
     ) -> Result<SecretResponse, SecretsManagerError> {
-        get_secret(self.client, input).await
+        get_secret(&self.client, input).await
     }
 
     pub async fn get_by_ids(
         &self,
         input: SecretsGetRequest,
     ) -> Result<SecretsResponse, SecretsManagerError> {
-        get_secrets_by_ids(self.client, input).await
+        get_secrets_by_ids(&self.client, input).await
     }
 
     pub async fn create(
         &self,
         input: &SecretCreateRequest,
     ) -> Result<SecretResponse, SecretsManagerError> {
-        create_secret(self.client, input).await
+        create_secret(&self.client, input).await
     }
 
     pub async fn list(
         &self,
         input: &SecretIdentifiersRequest,
     ) -> Result<SecretIdentifiersResponse, SecretsManagerError> {
-        list_secrets(self.client, input).await
+        list_secrets(&self.client, input).await
     }
 
     pub async fn list_by_project(
         &self,
         input: &SecretIdentifiersByProjectRequest,
     ) -> Result<SecretIdentifiersResponse, SecretsManagerError> {
-        list_secrets_by_project(self.client, input).await
+        list_secrets_by_project(&self.client, input).await
     }
 
     pub async fn update(
         &self,
         input: &SecretPutRequest,
     ) -> Result<SecretResponse, SecretsManagerError> {
-        update_secret(self.client, input).await
+        update_secret(&self.client, input).await
     }
 
     pub async fn delete(
         &self,
         input: SecretsDeleteRequest,
     ) -> Result<SecretsDeleteResponse, SecretsManagerError> {
-        delete_secrets(self.client, input).await
+        delete_secrets(&self.client, input).await
     }
 
     pub async fn sync(
         &self,
         input: &SecretsSyncRequest,
     ) -> Result<SecretsSyncResponse, SecretsManagerError> {
-        sync_secrets(self.client, input).await
+        sync_secrets(&self.client, input).await
     }
 }
 
-pub trait ClientSecretsExt<'a> {
-    fn secrets(&'a self) -> ClientSecrets<'a>;
+pub trait ClientSecretsExt {
+    fn secrets(&self) -> ClientSecrets;
 }
 
-impl<'a> ClientSecretsExt<'a> for Client {
-    fn secrets(&'a self) -> ClientSecrets<'a> {
-        ClientSecrets::new(self)
+impl ClientSecretsExt for Client {
+    fn secrets(&self) -> ClientSecrets {
+        ClientSecrets::new(self.clone())
     }
 }

crates/bitwarden-core/src/auth/auth_client.rs

@@ -29,11 +29,11 @@ use crate::{
     client::encryption_settings::EncryptionSettingsError,
 };
 
-pub struct AuthClient<'a> {
-    pub(crate) client: &'a crate::Client,
+pub struct AuthClient {
+    pub(crate) client: crate::Client,
 }
 
-impl AuthClient<'_> {
+impl AuthClient {
     pub async fn renew_token(&self) -> Result<(), LoginError> {
         renew_token(&self.client.internal).await
     }
@@ -43,12 +43,12 @@ impl AuthClient<'_> {
         &self,
         input: &AccessTokenLoginRequest,
     ) -> Result<AccessTokenLoginResponse, LoginError> {
-        login_access_token(self.client, input).await
+        login_access_token(&self.client, input).await
     }
 }
 
 #[cfg(feature = "internal")]
-impl AuthClient<'_> {
+impl AuthClient {
     pub fn password_strength(
         &self,
         password: String,
@@ -82,7 +82,7 @@ impl AuthClient<'_> {
         org_public_key: String,
         remember_device: bool,
     ) -> Result<RegisterTdeKeyResponse, EncryptionSettingsError> {
-        make_register_tde_keys(self.client, email, org_public_key, remember_device)
+        make_register_tde_keys(&self.client, email, org_public_key, remember_device)
     }
 
     pub fn make_key_connector_keys(&self) -> Result<KeyConnectorResponse, CryptoError> {
@@ -91,58 +91,58 @@ impl AuthClient<'_> {
     }
 
     pub async fn register(&self, input: &RegisterRequest) -> Result<(), RegisterError> {
-        register(self.client, input).await
+        register(&self.client, input).await
     }
 
     pub async fn prelogin(&self, email: String) -> Result<Kdf, PreloginError> {
         use crate::auth::login::prelogin;
 
-        prelogin(self.client, email).await
+        prelogin(&self.client, email).await
     }
 
     pub async fn login_password(
         &self,
         input: &PasswordLoginRequest,
     ) -> Result<PasswordLoginResponse, LoginError> {
-        login_password(self.client, input).await
+        login_password(&self.client, input).await
     }
 
     pub async fn login_api_key(
         &self,
         input: &ApiKeyLoginRequest,
     ) -> Result<ApiKeyLoginResponse, LoginError> {
-        login_api_key(self.client, input).await
+        login_api_key(&self.client, input).await
     }
 
     pub async fn send_two_factor_email(
         &self,
         tf: &TwoFactorEmailRequest,
     ) -> Result<(), TwoFactorEmailError> {
-        send_two_factor_email(self.client, tf).await
+        send_two_factor_email(&self.client, tf).await
     }
 
     pub fn validate_password(
         &self,
         password: String,
         password_hash: String,
     ) -> Result<bool, AuthValidateError> {
-        validate_password(self.client, password, password_hash)
+        validate_password(&self.client, password, password_hash)
     }
 
     pub fn validate_password_user_key(
         &self,
         password: String,
         encrypted_user_key: String,
     ) -> Result<String, AuthValidateError> {
-        validate_password_user_key(self.client, password, encrypted_user_key)
+        validate_password_user_key(&self.client, password, encrypted_user_key)
     }
 
     pub fn validate_pin(
         &self,
         pin: String,
         pin_protected_user_key: EncString,
     ) -> Result<bool, AuthValidateError> {
-        validate_pin(self.client, pin, pin_protected_user_key)
+        validate_pin(&self.client, pin, pin_protected_user_key)
     }
 
     pub fn new_auth_request(&self, email: &str) -> Result<AuthRequestResponse, CryptoError> {
@@ -153,24 +153,24 @@ impl AuthClient<'_> {
         &self,
         public_key: String,
     ) -> Result<AsymmetricEncString, ApproveAuthRequestError> {
-        approve_auth_request(self.client, public_key)
+        approve_auth_request(&self.client, public_key)
     }
 
     pub fn trust_device(&self) -> Result<TrustDeviceResponse, TrustDeviceError> {
-        trust_device(self.client)
+        trust_device(&self.client)
     }
 }
 
 #[cfg(feature = "internal")]
-impl AuthClient<'_> {
+impl AuthClient {
     pub async fn login_device(
         &self,
         email: String,
         device_identifier: String,
     ) -> Result<NewAuthRequestResponse, LoginError> {
         use crate::auth::login::send_new_auth_request;
 
-        send_new_auth_request(self.client, email, device_identifier).await
+        send_new_auth_request(&self.client, email, device_identifier).await
     }
 
     pub async fn login_device_complete(
@@ -179,7 +179,7 @@ impl AuthClient<'_> {
     ) -> Result<(), LoginError> {
         use crate::auth::login::complete_auth_request;
 
-        complete_auth_request(self.client, auth_req).await
+        complete_auth_request(&self.client, auth_req).await
     }
 }
 
@@ -205,9 +205,11 @@ fn trust_device(client: &Client) -> Result<TrustDeviceResponse, TrustDeviceError
     Ok(DeviceKey::trust_device(user_key)?)
 }
 
-impl<'a> Client {
-    pub fn auth(&'a self) -> AuthClient<'a> {
-        AuthClient { client: self }
+impl Client {
+    pub fn auth(&self) -> AuthClient {
+        AuthClient {
+            client: self.clone(),
+        }
     }
 }
 

crates/bitwarden-core/src/client/client.rs

@@ -12,10 +12,14 @@ use crate::client::{
 };
 
 /// The main struct to interact with the Bitwarden SDK.
-#[derive(Debug)]
+#[derive(Debug, Clone)]
 pub struct Client {
+    // Important: The [`Client`] struct requires its `Clone` implementation to return an owned
+    // reference to the same instance. This is required to properly use the FFI API, where we can't
+    // just use normal Rust references effectively. For this to happen, any mutable state needs
+    // to be behind an Arc, ideally as part of the existing [`InternalClient`] struct.
     #[doc(hidden)]
-    pub internal: InternalClient,
+    pub internal: Arc<InternalClient>,
 }
 
 impl Client {
@@ -70,7 +74,7 @@ impl Client {
         };
 
         Self {
-            internal: InternalClient {
+            internal: Arc::new(InternalClient {
                 tokens: RwLock::new(Tokens::default()),
                 login_method: RwLock::new(None),
                 #[cfg(feature = "internal")]
@@ -82,7 +86,7 @@ impl Client {
                 })),
                 external_client,
                 key_store: KeyStore::default(),
-            },
+            }),
         }
     }
 }

crates/bitwarden-core/src/mobile/client_kdf.rs

@@ -2,11 +2,11 @@ use bitwarden_crypto::{CryptoError, HashPurpose, Kdf};
 
 use crate::{mobile::kdf::hash_password, Client};
 
-pub struct ClientKdf<'a> {
-    pub(crate) _client: &'a crate::Client,
+pub struct ClientKdf {
+    pub(crate) _client: crate::Client,
 }
 
-impl ClientKdf<'_> {
+impl ClientKdf {
     pub async fn hash_password(
         &self,
         email: String,
@@ -18,8 +18,10 @@ impl ClientKdf<'_> {
     }
 }
 
-impl<'a> Client {
-    pub fn kdf(&'a self) -> ClientKdf<'a> {
-        ClientKdf { _client: self }
+impl Client {
+    pub fn kdf(&self) -> ClientKdf {
+        ClientKdf {
+            _client: self.clone(),
+        }
     }
 }