feat: add support for FlatError in wasm

Cargo.toml

@@ -56,7 +56,6 @@ 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"] }
-wasm-bindgen-futures = "0.4.41"
 
 [workspace.lints.clippy]
 unused_async = "deny"

crates/bitwarden-core/Cargo.toml

@@ -49,6 +49,7 @@ 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 }
+bitwarden-error = { version = "1.0.0", path = "../bitwarden-error" }
 
 [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,14 +3,15 @@ use std::collections::HashMap;
 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;
 
-#[derive(Debug, Error)]
+#[derive(Debug, Error, FlatError)]
 pub enum EncryptionSettingsError {
     #[error("Cryptography error, {0}")]
     Crypto(#[from] bitwarden_crypto::CryptoError),

crates/bitwarden-wasm-internal/Cargo.toml

@@ -17,6 +17,7 @@ crate-type = ["cdylib"]
 [dependencies]
 bitwarden-core = { workspace = true, features = ["wasm", "internal"] }
 bitwarden-crypto = { workspace = true, features = ["wasm"] }
+bitwarden-error = { version = "1.0.0", path = "../bitwarden-error" }
 bitwarden-vault = { workspace = true, features = ["wasm"] }
 console_error_panic_hook = "0.1.7"
 console_log = { version = "1.0.0", features = ["color"] }

crates/bitwarden-wasm-internal/src/error.js

@@ -0,0 +1,13 @@
+/**
+ * Error thrown by the WASM module.
+ * @param {string} message - Error message.
+ * @extends Error
+ */
+class WasmError extends Error {
+  constructor(message, name) {
+    super(message);
+    this.name = name ?? "WasmError";
+  }
+}
+
+exports.WasmError = WasmError;

crates/bitwarden-wasm-internal/src/error.rs

@@ -1,28 +1,48 @@
+use bitwarden_error::FlatError;
 use wasm_bindgen::prelude::*;
 
 // Importing an error class defined in JavaScript instead of defining it in Rust
 // allows us to extend the `Error` class. It also provides much better console output.
-#[wasm_bindgen]
+#[wasm_bindgen(module = "/src/error.js")]
 extern "C" {
-    #[wasm_bindgen(js_name = Error)]
-    type JsError;
+    type WasmError;
 
-    #[wasm_bindgen(constructor, js_class = Error)]
-    fn new(message: String) -> JsError;
+    #[wasm_bindgen(constructor)]
+    fn new(message: String, name: Option<String>) -> WasmError;
 }
 
 pub type Result<T, E = GenericError> = std::result::Result<T, E>;
 
 pub struct GenericError(pub String);
 
+pub struct FlattenedError {
+    pub variant: String,
+    pub message: String,
+}
+
 impl<T: ToString> From<T> for GenericError {
     fn from(error: T) -> Self {
         GenericError(error.to_string())
     }
 }
 
+impl<T: FlatError> From<T> for FlattenedError {
+    fn from(error: T) -> Self {
+        FlattenedError {
+            variant: error.get_variant().to_owned(),
+            message: error.get_message().to_owned(),
+        }
+    }
+}
+
 impl From<GenericError> for JsValue {
     fn from(error: GenericError) -> Self {
-        JsError::new(error.0).into()
+        WasmError::new(error.0, None).into()
+    }
+}
+
+impl From<FlattenedError> for JsValue {
+    fn from(error: FlattenedError) -> Self {
+        WasmError::new(error.message, Some(error.variant)).into()
     }
 }