Simplify internal wasm error handling

Derive From for conveting internal errors to JsValue with Into::into.

Author: cycraig

bindings/wasm/Cargo.toml

@@ -20,6 +20,7 @@ js-sys = { version = "0.3" }
 serde = { version = "1.0", features = ["derive"] }
 wasm-bindgen = { version = "0.2", features = ["serde-serialize"] }
 wasm-bindgen-futures = { version = "0.4", default-features = false }
+flat-enum = { version = "0.1", default-features = false, path = "../../flat-enum" }
 
 [dependencies.identity]
 version = "=0.3.0"
@@ -29,6 +30,7 @@ features = ["comm", "wasm"]
 
 [dev-dependencies]
 wasm-bindgen-test = { version = "0.3" }
+serde_json = { version = "1.0" }
 
 [target.'cfg(target_arch = "wasm32")'.dependencies]
 chrono = { version = "0.4", features = ["wasmbind"] }

bindings/wasm/src/credential/credential.rs

@@ -35,23 +35,23 @@ impl VerifiableCredential {
     if !base.contains_key("@context") {
       base.insert(
         "@context".into(),
-        Credential::<()>::base_context().serde_into().map_err(err)?,
+        Credential::<()>::base_context().serde_into()?,
       );
     }
 
     let mut types: Vec<String> = match base.remove("type") {
-      Some(value) => value.serde_into().map(OneOrMany::into_vec).map_err(err)?,
+      Some(value) => value.serde_into().map(OneOrMany::into_vec)?,
       None => Vec::new(),
     };
 
     types.insert(0, Credential::<()>::base_type().into());
-    base.insert("type".into(), types.serde_into().map_err(err)?);
+    base.insert("type".into(), types.serde_into()?);
 
     if !base.contains_key("issuanceDate") {
       base.insert("issuanceDate".into(), Timestamp::now_utc().to_string().into());
     }
 
-    base.serde_into().map_err(err).map(Self)
+    base.serde_into().map_err(Into::into).map(Self)
   }
 
   #[wasm_bindgen]

bindings/wasm/src/credential/presentation.rs

@@ -25,7 +25,7 @@ impl VerifiablePresentation {
     presentation_id: Option<String>,
   ) -> Result<VerifiablePresentation, JsValue> {
     let credentials: OneOrMany<Credential> = credential_data.into_serde().map_err(err)?;
-    let holder_url: Url = Url::parse(holder_doc.0.id().as_str()).map_err(err)?;
+    let holder_url: Url = Url::parse(holder_doc.0.id().as_str())?;
 
     let mut builder: PresentationBuilder = PresentationBuilder::default().holder(holder_url);
 
@@ -38,10 +38,10 @@ impl VerifiablePresentation {
     }
 
     if let Some(presentation_id) = presentation_id {
-      builder = builder.id(Url::parse(presentation_id).map_err(err)?);
+      builder = builder.id(Url::parse(presentation_id)?);
     }
 
-    builder.build().map_err(err).map(Self)
+    builder.build().map_err(Into::into).map(Self)
   }
 
   /// Serializes a `VerifiablePresentation` object as a JSON object.

bindings/wasm/src/crypto/key_pair.rs

@@ -31,14 +31,14 @@ impl KeyPair {
   /// Generates a new `KeyPair` object.
   #[wasm_bindgen(constructor)]
   pub fn new(type_: KeyType) -> Result<KeyPair, JsValue> {
-    KeyPair_::new(type_.into()).map_err(err).map(Self)
+    KeyPair_::new(type_.into()).map_err(Into::into).map(Self)
   }
 
   /// Parses a `KeyPair` object from base58-encoded public/secret keys.
   #[wasm_bindgen(js_name = fromBase58)]
   pub fn from_base58(type_: KeyType, public_key: &str, secret_key: &str) -> Result<KeyPair, JsValue> {
-    let public: PublicKey = decode_b58(public_key).map_err(err)?.into();
-    let secret: SecretKey = decode_b58(secret_key).map_err(err)?.into();
+    let public: PublicKey = decode_b58(public_key)?.into();
+    let secret: SecretKey = decode_b58(secret_key)?.into();
 
     Ok(Self((type_.into(), public, secret).into()))
   }

bindings/wasm/src/utils.rs

@@ -3,10 +3,42 @@
 
 use wasm_bindgen::JsValue;
 
-/// Convert errors so they are readable in JS
+/// Convert errors to strings so they are readable in JS
 pub fn err<T>(error: T) -> JsValue
 where
   T: ToString,
 {
   error.to_string().into()
 }
+
+// Alternative to implementing From for JsValue when deriving FlatEnum
+// /// Convert errors that derive FlatEnum into JS
+// pub fn flat_err<T, V>(error: T) -> JsValue
+// where
+//   T: flat_enum::IntoFlatEnum<V>,
+//   V: flat_enum::FlatEnum,
+// {
+//   // TODO: check that unwrap is infallible here?
+//   JsValue::from_serde(&error.into_flat_enum()).unwrap()
+// }
+
+#[cfg(test)]
+mod tests {
+  use flat_enum::IntoFlatEnum;
+
+  #[test]
+  fn test_js_error() {
+    let err = identity::credential::Error::DIDError(
+      identity::did::Error::CoreError(
+        identity::core::Error::DecodeBitmap(
+          std::io::Error::new(std::io::ErrorKind::Other, "something went wrong!")
+        )
+      )
+    );
+    println!("{}", err.to_string()); // Failed to decode roaring bitmap: something went wrong!
+    let json_str = serde_json::to_string(&err.to_string()).unwrap();
+    println!("{}", json_str); // "Failed to decode roaring bitmap: something went wrong!"
+    let json = serde_json::to_string(&err.into_flat_enum()).unwrap();
+    println!("{}", json); // {"code":"DIDError","description":"Failed to decode roaring bitmap: something went wrong!"}
+  }
+}