[PM-8301] Create bitwarden-core with macro and uniffi (#824)

Extract the `require` macro and common uniffi logic to a new crate
called `bitwarden-core` since it's required for extracting other
bitwarden functionality.

.github/workflows/publish-rust-crates.yml

@@ -29,6 +29,11 @@ on:
         required: true
         default: true
         type: boolean
+      publish_bitwarden-core:
+        description: "Publish bitwarden-core crate"
+        required: true
+        default: true
+        type: boolean
       publish_bitwarden-crypto:
         description: "Publish bitwarden-crypto crate"
         required: true
@@ -81,6 +86,7 @@ jobs:
           PUBLISH_BITWARDEN: ${{ github.event.inputs.publish_bitwarden }}
           PUBLISH_BITWARDEN_API_API: ${{ github.event.inputs.publish_bitwarden-api-api }}
           PUBLISH_BITWARDEN_API_IDENTITY: ${{ github.event.inputs.publish_bitwarden-api-identity }}
+          PUBLISH_BITWARDEN_CORE: ${{ github.event.inputs.publish_bitwarden-core }}
           PUBLISH_BITWARDEN_CRYPTO: ${{ github.event.inputs.publish_bitwarden-crypto }}
           PUBLISH_BITWARDEN_CLI: ${{ github.event.inputs.publish_bitwarden-cli }}
           PUBLISH_BITWARDEN_GENERATORS: ${{ github.event.inputs.publish_bitwarden-generators }}
@@ -111,6 +117,11 @@ jobs:
             PACKAGES_LIST="$PACKAGES_LIST bitwarden-api-identity"
           fi
 
+          if [[ "$PUBLISH_BITWARDEN_CORE" == "true" ]]; then
+            PACKAGES_COMMAND="$PACKAGES_COMMAND -p bitwarden-core"
+            PACKAGES_LIST="$PACKAGES_LIST bitwarden-core"
+          fi
+
           if [[ "$PUBLISH_BITWARDEN_CRYPTO" == "true" ]]; then
             PACKAGES_COMMAND="$PACKAGES_COMMAND -p bitwarden-crypto"
             PACKAGES_LIST="$PACKAGES_LIST bitwarden-crypto"

Cargo.toml

@@ -21,6 +21,7 @@ bitwarden = { path = "crates/bitwarden", version = "=0.5.0" }
 bitwarden-api-api = { path = "crates/bitwarden-api-api", version = "=0.5.0" }
 bitwarden-api-identity = { path = "crates/bitwarden-api-identity", version = "=0.5.0" }
 bitwarden-cli = { path = "crates/bitwarden-cli", version = "=0.5.0" }
+bitwarden-core = { path = "crates/bitwarden-core", version = "=0.5.0" }
 bitwarden-crypto = { path = "crates/bitwarden-crypto", version = "=0.5.0" }
 bitwarden-exporters = { path = "crates/bitwarden-exporters", version = "=0.5.0" }
 bitwarden-generators = { path = "crates/bitwarden-generators", version = "=0.5.0" }

crates/bitwarden-core/Cargo.toml

@@ -0,0 +1,26 @@
+[package]
+name = "bitwarden-core"
+description = """
+Internal crate for the bitwarden crate. Do not use.
+"""
+
+version.workspace = true
+authors.workspace = true
+edition.workspace = true
+rust-version.workspace = true
+homepage.workspace = true
+repository.workspace = true
+license-file.workspace = true
+keywords.workspace = true
+
+[features]
+uniffi = ["dep:uniffi"]
+
+[dependencies]
+chrono = { version = ">=0.4.26, <0.5", default-features = false }
+uniffi = { version = "=0.27.2", optional = true }
+uuid = { version = ">=1.3.3, <2.0", features = ["serde"] }
+thiserror = ">=1.0.40, <2.0"
+
+[lints]
+workspace = true

crates/bitwarden-core/src/error.rs

@@ -0,0 +1,19 @@
+use thiserror::Error;
+
+#[derive(Debug, Error)]
+#[error("The response received was missing a required field: {0}")]
+pub struct MissingFieldError(pub &'static str);
+
+/// This macro is used to require that a value is present or return an error otherwise.
+/// It is equivalent to using `val.ok_or(Error::MissingFields)?`, but easier to use and
+/// with a more descriptive error message.
+/// Note that this macro will return early from the function if the value is not present.
+#[macro_export]
+macro_rules! require {
+    ($val:expr) => {
+        match $val {
+            Some(val) => val,
+            None => return Err($crate::MissingFieldError(stringify!($val)).into()),
+        }
+    };
+}

crates/bitwarden-core/src/lib.rs

@@ -0,0 +1,7 @@
+#[cfg(feature = "uniffi")]
+uniffi::setup_scaffolding!();
+#[cfg(feature = "uniffi")]
+mod uniffi_support;
+
+mod error;
+pub use error::MissingFieldError;

crates/bitwarden-core/src/uniffi_support.rs

@@ -0,0 +1,41 @@
+use uuid::Uuid;
+
+use crate::UniffiCustomTypeConverter;
+
+type DateTime = chrono::DateTime<chrono::Utc>;
+uniffi::custom_type!(DateTime, std::time::SystemTime);
+
+impl UniffiCustomTypeConverter for chrono::DateTime<chrono::Utc> {
+    type Builtin = std::time::SystemTime;
+
+    fn into_custom(val: Self::Builtin) -> uniffi::Result<Self> {
+        Ok(Self::from(val))
+    }
+
+    fn from_custom(obj: Self) -> Self::Builtin {
+        obj.into()
+    }
+}
+
+uniffi::custom_type!(Uuid, String);
+
+impl UniffiCustomTypeConverter for Uuid {
+    type Builtin = String;
+
+    fn into_custom(val: Self::Builtin) -> uniffi::Result<Self> {
+        Uuid::parse_str(val.as_str()).map_err(|e| e.into())
+    }
+
+    fn from_custom(obj: Self) -> Self::Builtin {
+        obj.to_string()
+    }
+}
+
+// Uniffi doesn't emit unused types, this is a dummy record to ensure that the custom type
+// converters are emitted
+#[allow(dead_code)]
+#[derive(uniffi::Record)]
+struct UniffiConverterDummyRecord {
+    uuid: Uuid,
+    date: DateTime,
+}

crates/bitwarden-core/uniffi.toml

@@ -0,0 +1,9 @@
+[bindings.kotlin]
+package_name = "com.bitwarden.core"
+generate_immutable_records = true
+android = true
+
+[bindings.swift]
+ffi_module_name = "BitwardenCoreFFI"
+module_name = "BitwardenCore"
+generate_immutable_records = true

crates/bitwarden-crypto/Cargo.toml

@@ -18,7 +18,6 @@ default = []
 
 uniffi = ["dep:uniffi"]  # Uniffi bindings
 no-memory-hardening = [] # Disable memory hardening features
-test = []                # Test methods
 
 [dependencies]
 aes = { version = ">=0.8.2, <0.9", features = ["zeroize"] }

crates/bitwarden-exporters/Cargo.toml

@@ -28,8 +28,5 @@ serde_json = ">=1.0.96, <2.0"
 thiserror = ">=1.0.40, <2.0"
 uuid = { version = ">=1.3.3, <2.0", features = ["serde", "v4"] }
 
-[dev-dependencies]
-bitwarden-crypto = { workspace = true, features = ["test"] }
-
 [lints]
 workspace = true

crates/bitwarden-uniffi/Cargo.toml

@@ -21,6 +21,7 @@ bench = false
 async-lock = "3.3.0"
 async-trait = "0.1.80"
 bitwarden = { workspace = true, features = ["internal", "uniffi"] }
+bitwarden-core = { workspace = true, features = ["uniffi"] }
 bitwarden-crypto = { workspace = true, features = ["uniffi"] }
 bitwarden-generators = { workspace = true, features = ["uniffi"] }
 chrono = { version = ">=0.4.26, <0.5", features = [

crates/bitwarden-uniffi/src/uniffi_support.rs

@@ -3,7 +3,7 @@ use uuid::Uuid;
 
 // Forward the type definitions to the main bitwarden crate
 type DateTime = chrono::DateTime<chrono::Utc>;
-uniffi::ffi_converter_forward!(DateTime, bitwarden::UniFfiTag, crate::UniFfiTag);
+uniffi::ffi_converter_forward!(DateTime, bitwarden_core::UniFfiTag, crate::UniFfiTag);
 uniffi::ffi_converter_forward!(EncString, bitwarden::UniFfiTag, crate::UniFfiTag);
 uniffi::ffi_converter_forward!(AsymmetricEncString, bitwarden::UniFfiTag, crate::UniFfiTag);
-uniffi::ffi_converter_forward!(Uuid, bitwarden::UniFfiTag, crate::UniFfiTag);
+uniffi::ffi_converter_forward!(Uuid, bitwarden_core::UniFfiTag, crate::UniFfiTag);

crates/bitwarden/Cargo.toml

@@ -24,6 +24,7 @@ no-memory-hardening = [
     "bitwarden-crypto/no-memory-hardening",
 ] # Disable memory hardening features
 uniffi = [
+    "bitwarden-core/uniffi",
     "bitwarden-crypto/uniffi",
     "bitwarden-generators/uniffi",
     "dep:uniffi",
@@ -39,6 +40,7 @@ async-trait = ">=0.1.80, <0.2"
 base64 = ">=0.21.2, <0.23"
 bitwarden-api-api = { workspace = true }
 bitwarden-api-identity = { workspace = true }
+bitwarden-core = { workspace = true }
 bitwarden-crypto = { workspace = true }
 bitwarden-exporters = { workspace = true, optional = true }
 bitwarden-generators = { workspace = true, optional = true }
@@ -95,7 +97,6 @@ reqwest = { version = ">=0.12, <0.13", features = [
 security-framework = { version = "=2.10" }
 
 [dev-dependencies]
-bitwarden-crypto = { workspace = true, features = ["test"] }
 rand_chacha = "0.3.1"
 tokio = { version = "1.36.0", features = ["rt", "macros"] }
 wiremock = "0.6.0"

crates/bitwarden/src/admin_console/policy.rs

@@ -1,12 +1,13 @@
 use std::collections::HashMap;
 
 use bitwarden_api_api::models::PolicyResponseModel;
+use bitwarden_core::require;
 use schemars::JsonSchema;
 use serde::{Deserialize, Serialize};
 use serde_repr::{Deserialize_repr, Serialize_repr};
 use uuid::Uuid;
 
-use crate::error::{require, Error, Result};
+use crate::error::{Error, Result};
 
 #[derive(Serialize, Deserialize, Debug, JsonSchema)]
 pub struct Policy {

crates/bitwarden/src/auth/login/access_token.rs

@@ -1,6 +1,7 @@
 use std::path::{Path, PathBuf};
 
 use base64::{engine::general_purpose::STANDARD, Engine};
+use bitwarden_core::require;
 use bitwarden_crypto::{EncString, KeyDecryptable, SymmetricCryptoKey};
 use chrono::Utc;
 use schemars::JsonSchema;
@@ -14,7 +15,7 @@ use crate::{
         AccessToken, JWTToken,
     },
     client::{LoginMethod, ServiceAccountLoginMethod},
-    error::{require, Error, Result},
+    error::{Error, Result},
     secrets_manager::state::{self, ClientState},
     Client,
 };

crates/bitwarden/src/auth/login/api_key.rs

@@ -1,3 +1,4 @@
+use bitwarden_core::require;
 use bitwarden_crypto::{EncString, MasterKey};
 use schemars::JsonSchema;
 use serde::{Deserialize, Serialize};
@@ -9,7 +10,7 @@ use crate::{
         JWTToken,
     },
     client::{LoginMethod, UserLoginMethod},
-    error::{require, Result},
+    error::Result,
     Client,
 };
 

crates/bitwarden/src/auth/login/auth_request.rs

@@ -2,6 +2,7 @@ use bitwarden_api_api::{
     apis::auth_requests_api::{auth_requests_id_response_get, auth_requests_post},
     models::{AuthRequestCreateRequestModel, AuthRequestType},
 };
+use bitwarden_core::require;
 use bitwarden_crypto::Kdf;
 use uuid::Uuid;
 
@@ -11,7 +12,7 @@ use crate::{
         auth_request::new_auth_request,
     },
     client::{LoginMethod, UserLoginMethod},
-    error::{require, Result},
+    error::Result,
     mobile::crypto::{AuthRequestMethod, InitUserCryptoMethod, InitUserCryptoRequest},
     Client,
 };

crates/bitwarden/src/auth/login/password.rs

@@ -22,9 +22,10 @@ pub(crate) async fn login_password(
     client: &mut Client,
     input: &PasswordLoginRequest,
 ) -> Result<PasswordLoginResponse> {
+    use bitwarden_core::require;
     use bitwarden_crypto::{EncString, HashPurpose, MasterKey};
 
-    use crate::{client::UserLoginMethod, error::require};
+    use crate::client::UserLoginMethod;
 
     info!("password logging in");
 

crates/bitwarden/src/error.rs

@@ -15,6 +15,8 @@ use thiserror::Error;
 
 #[derive(Debug, Error)]
 pub enum Error {
+    #[error(transparent)]
+    MissingFieldError(#[from] bitwarden_core::MissingFieldError),
     #[error("The client is not authenticated or the session has expired")]
     NotAuthenticated,
 
@@ -26,8 +28,6 @@ pub enum Error {
 
     #[error("The response received was invalid and could not be processed")]
     InvalidResponse,
-    #[error("The response received was missing some of the required fields: {0}")]
-    MissingFields(&'static str),
 
     #[error("Cryptography error, {0}")]
     Crypto(#[from] bitwarden_crypto::CryptoError),
@@ -154,18 +154,4 @@ macro_rules! impl_bitwarden_error {
 impl_bitwarden_error!(ApiError);
 impl_bitwarden_error!(IdentityError);
 
-/// This macro is used to require that a value is present or return an error otherwise.
-/// It is equivalent to using `val.ok_or(Error::MissingFields)?`, but easier to use and
-/// with a more descriptive error message.
-/// Note that this macro will return early from the function if the value is not present.
-macro_rules! require {
-    ($val:expr) => {
-        match $val {
-            Some(val) => val,
-            None => return Err($crate::error::Error::MissingFields(stringify!($val))),
-        }
-    };
-}
-pub(crate) use require;
-
 pub type Result<T, E = Error> = std::result::Result<T, E>;

crates/bitwarden/src/platform/get_user_api_key.rs

@@ -2,6 +2,7 @@ use bitwarden_api_api::{
     apis::accounts_api::accounts_api_key_post,
     models::{ApiKeyResponseModel, SecretVerificationRequestModel},
 };
+use bitwarden_core::require;
 use bitwarden_crypto::{HashPurpose, MasterKey};
 use log::{debug, info};
 use schemars::JsonSchema;
@@ -10,7 +11,7 @@ use serde::{Deserialize, Serialize};
 use super::SecretVerificationRequest;
 use crate::{
     client::{LoginMethod, UserLoginMethod},
-    error::{require, Error, Result},
+    error::{Error, Result},
     Client,
 };
 

crates/bitwarden/src/secrets_manager/projects/delete.rs

@@ -1,14 +1,12 @@
 use bitwarden_api_api::models::{
     BulkDeleteResponseModel, BulkDeleteResponseModelListResponseModel,
 };
+use bitwarden_core::require;
 use schemars::JsonSchema;
 use serde::{Deserialize, Serialize};
 use uuid::Uuid;
 
-use crate::{
-    client::Client,
-    error::{require, Result},
-};
+use crate::{client::Client, error::Result};
 
 #[derive(Serialize, Deserialize, Debug, JsonSchema)]
 #[serde(rename_all = "camelCase", deny_unknown_fields)]