[PM-13660] implement catchable non generic error types

Cargo.toml

@@ -29,6 +29,8 @@ bitwarden-generators = { path = "crates/bitwarden-generators", version = "=1.0.0
 bitwarden-send = { path = "crates/bitwarden-send", version = "=1.0.0" }
 bitwarden-sm = { path = "bitwarden_license/bitwarden-sm", version = "=1.0.0" }
 bitwarden-vault = { path = "crates/bitwarden-vault", version = "=1.0.0" }
+bitwarden-error = { path = "crates/bitwarden-error", version = "=1.0.0" }
+bitwarden-error-macro = { path = "crates/bitwarden-error-macro", version = "=1.0.0" }
 
 # External crates that are expected to maintain a consistent version across all crates
 chrono = { version = ">=0.4.26, <0.5", features = [
@@ -56,6 +58,7 @@ uniffi = "=0.28.1"
 uuid = { version = ">=1.3.3, <2.0", features = ["serde", "v4"] }
 validator = { version = "0.18.1", features = ["derive"] }
 wasm-bindgen = { version = ">=0.2.91, <0.3", features = ["serde-serialize"] }
+js-sys = { version = ">=0.3.72, <0.4" }
 wasm-bindgen-futures = "0.4.41"
 
 [workspace.lints.clippy]

crates/bitwarden-core/Cargo.toml

@@ -20,7 +20,12 @@ no-memory-hardening = [
 ] # Disable memory hardening features
 uniffi = ["bitwarden-crypto/uniffi", "dep:uniffi"] # Uniffi bindings
 secrets = [] # Secrets manager API
-wasm = ["dep:wasm-bindgen", "dep:tsify-next"] # WASM support
+wasm = [
+    "bitwarden-error/wasm",
+    "dep:wasm-bindgen",
+    "dep:js-sys",
+    "dep:tsify-next",
+] # WASM support
 
 [dependencies]
 base64 = ">=0.22.1, <0.23"
@@ -49,6 +54,8 @@ wasm-bindgen = { workspace = true, optional = true }
 zeroize = { version = ">=1.7.0, <2.0", features = ["derive", "aarch64"] }
 zxcvbn = { version = ">=3.0.1, <4.0", optional = true }
 tsify-next = { workspace = true, optional = true }
+js-sys = { workspace = true, optional = true }
+bitwarden-error = { workspace = true }
 
 [target.'cfg(not(target_arch="wasm32"))'.dependencies]
 # By default, we use rustls as the TLS stack and rust-platform-verifier to support user-installed root certificates

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

@@ -3,13 +3,15 @@
 use bitwarden_crypto::{AsymmetricCryptoKey, CryptoError, KeyContainer, SymmetricCryptoKey};
 #[cfg(feature = "internal")]
 use bitwarden_crypto::{AsymmetricEncString, EncString, MasterKey};
+use bitwarden_error::prelude::*;
 use thiserror::Error;
 use uuid::Uuid;
 
 #[cfg(feature = "internal")]
 use crate::error::Result;
 use crate::VaultLocked;
 
+#[bitwarden_error(flat)]
 #[derive(Debug, Error)]
 pub enum EncryptionSettingsError {
     #[error("Cryptography error, {0}")]

crates/bitwarden-core/src/error.rs

@@ -4,6 +4,7 @@
 
 use bitwarden_api_api::apis::Error as ApiError;
 use bitwarden_api_identity::apis::Error as IdentityError;
+use bitwarden_error::prelude::*;
 use log::debug;
 use reqwest::StatusCode;
 use thiserror::Error;
@@ -12,6 +13,7 @@
 #[cfg(feature = "internal")]
 use crate::client::encryption_settings::EncryptionSettingsError;
 
+#[bitwarden_error(flat, export_as = "CoreError")]
 #[derive(Debug, Error)]
 pub enum Error {
     #[error(transparent)]

crates/bitwarden-error-macro/Cargo.toml

@@ -0,0 +1,33 @@
+[package]
+name = "bitwarden-error-macro"
+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]
+wasm = ["bitwarden-error/wasm"]
+
+[dependencies]
+darling = "0.20.10"
+proc-macro2 = "1.0.89"
+quote = "1.0.37"
+syn = "2.0.87"
+
+[lints]
+workspace = true
+
+[lib]
+proc-macro = true
+
+[dev-dependencies]
+bitwarden-error.workspace = true
+serde.workspace = true
+thiserror.workspace = true
+tsify-next.workspace = true
+js-sys.workspace = true
+wasm-bindgen.workspace = true

crates/bitwarden-error-macro/src/args.rs

@@ -0,0 +1,23 @@
+use darling::FromMeta;
+
+#[derive(FromMeta)]
+pub(crate) struct BitwardenErrorArgs {
+    #[darling(flatten)]
+    pub error_type: BitwardenErrorType,
+
+    #[darling(default)]
+    pub export_as: Option<String>,
+}
+
+#[derive(FromMeta)]
+#[darling(rename_all = "snake_case")]
+pub(crate) enum BitwardenErrorType {
+    /// The error is going to be converted into a string using the `ToString` trait
+    Basic,
+
+    /// The error is going to be converted into a flat error using the `FlatError` trait
+    Flat,
+
+    /// The entire error stack is going to be made available using `serde`
+    Full,
+}

crates/bitwarden-error-macro/src/attribute.rs

@@ -0,0 +1,49 @@
+use darling::{ast::NestedMeta, FromMeta};
+use quote::format_ident;
+
+use crate::args::{BitwardenErrorArgs, BitwardenErrorType};
+
+pub(crate) fn bitwarden_error(
+    args: proc_macro::TokenStream,
+    item: proc_macro::TokenStream,
+) -> proc_macro::TokenStream {
+    let attr_args = match NestedMeta::parse_meta_list(args.into()) {
+        Ok(v) => v,
+        Err(e) => {
+            return proc_macro::TokenStream::from(darling::Error::from(e).write_errors());
+        }
+    };
+
+    let args = match BitwardenErrorArgs::from_list(&attr_args) {
+        Ok(params) => params,
+        Err(error) => {
+            return proc_macro::TokenStream::from(error.write_errors());
+        }
+    };
+
+    let input = syn::parse_macro_input!(item as syn::DeriveInput);
+    let type_identifier = &input.ident;
+    let export_as_identifier = &args
+        .export_as
+        .as_ref()
+        .map(|export_as| format_ident!("{}", export_as))
+        .unwrap_or(input.ident.clone());
+
+    match args.error_type {
+        BitwardenErrorType::Basic => crate::basic::attribute::bitwarden_error_basic(
+            &input,
+            type_identifier,
+            export_as_identifier,
+        ),
+        BitwardenErrorType::Flat => crate::flat::attribute::bitwarden_error_flat(
+            &input,
+            type_identifier,
+            export_as_identifier,
+        ),
+        BitwardenErrorType::Full => crate::full::attribute::bitwarden_error_full(
+            &input,
+            type_identifier,
+            export_as_identifier,
+        ),
+    }
+}

crates/bitwarden-error-macro/src/basic/attribute.rs

@@ -0,0 +1,61 @@
+use quote::quote;
+
+pub(crate) fn bitwarden_error_basic(
+    input: &syn::DeriveInput,
+    type_identifier: &proc_macro2::Ident,
+    export_as_identifier: &proc_macro2::Ident,
+) -> proc_macro::TokenStream {
+    let wasm =
+        cfg!(feature = "wasm").then(|| basic_error_wasm(type_identifier, export_as_identifier));
+    quote! {
+        #input
+
+        #wasm
+    }
+    .into()
+}
+
+fn basic_error_wasm(
+    type_identifier: &proc_macro2::Ident,
+    export_as_identifier: &proc_macro2::Ident,
+) -> proc_macro2::TokenStream {
+    let export_as_identifier_str = export_as_identifier.to_string();
+    let is_error_function_name = format!("is{}", export_as_identifier);
+    let ts_code_str = format!(
+        r##"r#"
+            export interface {export_as_identifier} extends Error {{
+                name: "{export_as_identifier}";
+            }};
+
+            export function {is_error_function_name}(error: any): error is {export_as_identifier};
+        "#"##
+    );
+    let ts_code: proc_macro2::TokenStream = ts_code_str
+        .parse()
+        .expect("Could not generate TypeScript code");
+
+    quote! {
+        const _: () = {
+            use wasm_bindgen::prelude::*;
+
+            #[wasm_bindgen(typescript_custom_section)]
+            const TS_APPEND_CONTENT: &'static str = #ts_code;
+
+            #[wasm_bindgen(js_name = #is_error_function_name, skip_typescript)]
+            pub fn is_error(error: &JsValue) -> bool {
+                let name_js_value = js_sys::Reflect::get(&error, &JsValue::from_str("name")).unwrap_or(JsValue::NULL);
+                let name = name_js_value.as_string().unwrap_or_default();
+                name == #export_as_identifier_str
+            }
+
+            #[automatically_derived]
+            impl From<#type_identifier> for JsValue {
+                fn from(error: #type_identifier) -> Self {
+                    let js_error = SdkJsError::new(error.to_string());
+                    js_error.set_name(#export_as_identifier_str.to_owned());
+                    js_error.into()
+                }
+            }
+        };
+    }
+}

crates/bitwarden-error-macro/src/basic/mod.rs

@@ -0,0 +1 @@
+pub mod attribute;

crates/bitwarden-error-macro/src/flat/attribute.rs

@@ -0,0 +1,115 @@
+use quote::quote;
+use syn::Data;
+
+pub(crate) fn bitwarden_error_flat(
+    input: &syn::DeriveInput,
+    type_identifier: &proc_macro2::Ident,
+    export_as_identifier: &proc_macro2::Ident,
+) -> proc_macro::TokenStream {
+    match &input.data {
+        Data::Enum(data) => {
+            let variant_names = data.variants.iter().map(|variant| &variant.ident);
+            let match_arms = data.variants.iter().map(|variant| {
+                let variant_ident = &variant.ident;
+                let variant_str = variant_ident.to_string();
+
+                match variant.fields {
+                    syn::Fields::Unit => {
+                        quote! {
+                            #type_identifier::#variant_ident => #variant_str
+                        }
+                    }
+                    syn::Fields::Named(_) => {
+                        quote! {
+                            #type_identifier::#variant_ident { .. } => #variant_str
+                        }
+                    }
+                    syn::Fields::Unnamed(_) => {
+                        quote! {
+                            #type_identifier::#variant_ident(..) => #variant_str
+                        }
+                    }
+                }
+            });
+
+            let wasm = cfg!(feature = "wasm").then(|| {
+                flat_error_wasm(
+                    type_identifier,
+                    export_as_identifier,
+                    &variant_names.collect::<Vec<_>>(),
+                )
+            });
+
+            quote! {
+                #input
+                #wasm
+
+                #[automatically_derived]
+                impl ::bitwarden_error::prelude::FlatError for #type_identifier {
+                    fn error_variant(&self) -> &'static str {
+                        match &self {
+                            #(#match_arms), *
+                        }
+                    }
+                }
+            }
+            .into()
+        }
+        _ => syn::Error::new_spanned(input, "bitwarden_error can only be used with enums")
+            .to_compile_error()
+            .into(),
+    }
+}
+
+fn flat_error_wasm(
+    type_identifier: &proc_macro2::Ident,
+    export_as_identifier: &proc_macro2::Ident,
+    variant_names: &[&proc_macro2::Ident],
+) -> proc_macro2::TokenStream {
+    let export_as_identifier_str = export_as_identifier.to_string();
+    let is_error_function_name = format!("is{}", export_as_identifier);
+    let ts_variant_names = variant_names
+        .iter()
+        .map(|vn| format!(r#""{vn}""#))
+        .collect::<Vec<String>>()
+        .join("|");
+    let ts_code_str = format!(
+        r##"r#"
+            export interface {export_as_identifier_str} extends Error {{
+                name: "{export_as_identifier_str}";
+                variant: {ts_variant_names};
+            }};
+
+            export function {is_error_function_name}(error: any): error is {export_as_identifier_str};
+        "#"##,
+    );
+    let ts_code: proc_macro2::TokenStream = ts_code_str
+        .parse()
+        .expect("Could not generate TypeScript code");
+
+    quote! {
+        const _: () = {
+            use wasm_bindgen::prelude::*;
+
+            #[wasm_bindgen(typescript_custom_section)]
+            const TS_APPEND_CONTENT: &'static str = #ts_code;
+
+            #[wasm_bindgen(js_name = #is_error_function_name, skip_typescript)]
+            pub fn is_error(error: &JsValue) -> bool {
+                let name_js_value = js_sys::Reflect::get(&error, &JsValue::from_str("name")).unwrap_or(JsValue::NULL);
+                let name = name_js_value.as_string().unwrap_or_default();
+                name == #export_as_identifier_str
+            }
+
+            #[automatically_derived]
+            impl From<#type_identifier> for JsValue {
+                fn from(error: #type_identifier) -> Self {
+                    let js_error = SdkJsError::new(error.to_string());
+                    js_error.set_name(#export_as_identifier_str.to_owned());
+                    js_error.set_variant(error.error_variant().to_owned());
+                    js_error.into()
+                }
+            }
+        };
+    }
+}

crates/bitwarden-error-macro/src/flat/mod.rs

@@ -0,0 +1 @@
+pub mod attribute;

crates/bitwarden-error-macro/src/full/attribute.rs

@@ -0,0 +1,28 @@
+use darling::Error;
+use quote::quote;
+
+pub(crate) fn bitwarden_error_full(
+    input: &syn::DeriveInput,
+    type_identifier: &proc_macro2::Ident,
+    export_as_identifier: &proc_macro2::Ident,
+) -> proc_macro::TokenStream {
+    if type_identifier != export_as_identifier {
+        return Error::custom("`bitwarden_error(full)` does not currently support `export_as`")
+            .write_errors()
+            .into();
+    }
+
+    let wasm_attributes = cfg!(feature = "wasm").then(|| {
+        quote! {
+            #[derive(tsify_next::Tsify)]
+            #[tsify(into_wasm_abi)]
+        }
+    });
+
+    quote! {
+        #[derive(serde::Serialize)]
+        #wasm_attributes
+        #input
+    }
+    .into()
+}

crates/bitwarden-error-macro/src/full/mod.rs

@@ -0,0 +1 @@
+pub mod attribute;