Simplify internal wasm error handling

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

Author: cycraig

Cargo.toml

@@ -11,6 +11,7 @@ members = [
   "identity-iota",
 
   "flat-enum",
+  "flat-enum-derive",
   "flat-enum-tests",
 
   "examples",

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!"}
+  }
+}

flat-enum-derive/Cargo.toml

@@ -0,0 +1,19 @@
+[package]
+name = "flat-enum-derive"
+version = "0.1.0"
+edition = "2018"
+license = "Apache-2.0"
+publish = false
+
+[lib]
+name = "flat_enum_derive"
+proc-macro = true
+
+[features]
+default = []
+wasm = []
+
+[dependencies]
+proc-macro-error = { version = "1.0", default-features = false }
+quote = { version = "1.0", default-features = false }
+syn = { version = "1.0", features = ["extra-traits", "parsing", "derive"] }

flat-enum-derive/src/lib.rs

@@ -0,0 +1,135 @@
+use proc_macro::TokenStream;
+
+use syn::__private::TokenStream2;
+use syn::spanned::Spanned;
+use syn::{Data, DeriveInput, Fields};
+
+#[proc_macro_derive(FlatEnum)]
+#[proc_macro_error::proc_macro_error]
+pub fn derive_flat_enum(input: TokenStream) -> TokenStream {
+  let ast: DeriveInput = syn::parse_macro_input!(input as DeriveInput);
+
+  // Build the flat error struct and enum
+  gen_flat_enum(&ast)
+}
+
+fn gen_flat_enum(ast: &syn::DeriveInput) -> TokenStream {
+  let name = &ast.ident;
+  let data = &ast.data;
+
+  let flat_struct_name = quote::format_ident!("Flat{}", name.to_string());
+  let flat_enum_code_name = quote::format_ident!("Flat{}Code", name.to_string());
+
+  let mut flat_enum_code_variants;
+  let mut flat_enum_code_from_cases;
+
+  match data {
+    Data::Enum(data_enum) => {
+      flat_enum_code_variants = TokenStream2::new();
+      flat_enum_code_from_cases = TokenStream2::new();
+
+      // Iterate over enum variants
+      for variant in &data_enum.variants {
+        let variant_name = &variant.ident;
+
+        // Enum variants can:
+        // - have unnamed fields like `Variant(i32, i64)`
+        // - have named fields like `Variant {x: i32, y: i32}`
+        // - be a Unit like `Variant`
+        let fields_in_variant = match &variant.fields {
+          Fields::Unnamed(_) => quote::quote_spanned! { variant.span()=> (..) },
+          Fields::Unit => quote::quote_spanned! { variant.span()=> },
+          Fields::Named(_) => quote::quote_spanned! { variant.span()=> {..} },
+        };
+
+        // Generate a flat C-style enum variant
+        let variant_doc_string = format!("[{}::{}]", name.to_string(), variant_name.to_string());
+        flat_enum_code_variants.extend(quote::quote_spanned! {variant.span()=>
+          #[doc = #variant_doc_string]
+          #variant_name,
+        });
+
+        // Implement From<OriginalEnum> cases
+        // TODO: improve description strings, currently requires Debug to be implemented on the
+        //       original enum which includes the name in the string.
+        //       e.g. Enum::A => "A" - do we want "" instead?
+        //       e.g. Enum::B(1,2) => "B(1,2)" - do we want "(1,2)" instead?
+        //       e.g. Enum::C{"a","b"} => "C { "a", "b" }" - do we want "{ "a", "b" }" instead?
+        flat_enum_code_from_cases.extend(quote::quote_spanned! {variant.span()=>
+          #name::#variant_name #fields_in_variant => #flat_struct_name::new(#flat_enum_code_name::#variant_name, input.to_string()),
+        });
+      }
+    }
+    _ => proc_macro_error::abort_call_site!("FlatError is only supported for enums"),
+  };
+
+  // Optionally implement From<*> for JsValue
+  // Workaround since cannot implement From<T> for JsValue where T: IntoFlatEnum<dyn FlatEnum>
+  // nor T: IntoFlatEnum<#flat_struct_name>
+  #[allow(unused_mut, unused_assignments)]
+  let mut impl_js_value_from = quote::quote!{};
+  #[cfg(feature = "wasm")]
+  {
+    impl_js_value_from = quote::quote! {
+      use flat_enum::IntoFlatEnum;
+      impl From<#name> for wasm_bindgen::JsValue
+      {
+        fn from(input: #name) -> Self {
+          // TODO: check that unwrap always works?
+          wasm_bindgen::JsValue::from_serde(&input.into_flat_enum()).unwrap()
+        }
+      }
+    };
+  }
+
+  // Generate Flat* struct and Flat*Code enum
+  let (impl_generics, type_generics, where_clause) = ast.generics.split_for_impl();
+  let expanded = quote::quote! {
+    // Serializable wrapper struct
+    #[derive(Clone, Debug, serde::Serialize, serde::Deserialize)]
+    #[repr(C)]
+    pub struct #flat_struct_name {
+      pub code: #flat_enum_code_name,
+      pub description: String,
+    }
+
+    impl #flat_struct_name {
+      pub fn new(code: #flat_enum_code_name, description: String) -> Self {
+        Self {
+          code,
+          description,
+        }
+      }
+    }
+
+    // FlatEnum trait
+    impl flat_enum::FlatEnum for #flat_struct_name {}
+
+    // C-style enum
+    #[derive(Clone, Copy, Debug, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
+    #[repr(C)]
+    pub enum #flat_enum_code_name {
+      #flat_enum_code_variants
+    }
+
+    // From implementation
+    impl #impl_generics From<#name #type_generics> for #flat_struct_name #where_clause {
+      fn from(input: #name #type_generics) -> Self {
+        match &input {
+          #flat_enum_code_from_cases
+        }
+      }
+    }
+
+    // Add to_flat_enum() function to the original enum
+    impl #impl_generics flat_enum::IntoFlatEnum<#flat_struct_name> for #name #type_generics #where_clause {
+      fn into_flat_enum(self) -> #flat_struct_name {
+        #flat_struct_name::from(self)
+      }
+    }
+
+    #impl_js_value_from
+  };
+
+  TokenStream::from(expanded)
+}

flat-enum-tests/Cargo.toml

@@ -6,5 +6,5 @@ license = "Apache-2.0"
 publish = false
 
 [dev-dependencies]
-flat-enum = { version = "*", path = "../flat-enum" }
+flat-enum = { version = "*", path = "../flat-enum", default-features = false, features = ["derive"] }
 serde = { version = "1.0", default-features = false, features = ["alloc", "derive"] }

flat-enum-tests/tests/test.rs

@@ -2,69 +2,76 @@
 extern crate alloc;
 
 use alloc::borrow::ToOwned;
-use alloc::format;
 use alloc::string::String;
-use flat_enum::FlatEnum;
+use flat_enum::IntoFlatEnum;
+use core::fmt::Formatter;
+use alloc::string::ToString;
 
-#[derive(Debug, FlatEnum)]
-pub enum Enum {
+#[derive(Debug, flat_enum::derive::FlatEnum)]
+pub enum BasicEnum {
   A,
   B(String),
   C { a: String },
   D { a: String, b: i64 },
 }
 
+impl core::fmt::Display for BasicEnum {
+  fn fmt(&self, f: &mut Formatter<'_>) -> core::fmt::Result {
+    f.write_fmt(format_args!("{:?}", self))
+  }
+}
+
 #[test]
 fn test_flat_enum_basic() {
-  let a = FlatEnum {
-    code: FlatEnumCode::A,
+  let a = FlatBasicEnum {
+    code: FlatBasicEnumCode::A,
     description: "A".to_owned(),
   };
-  assert_eq!(a.code, FlatEnumCode::A);
+  assert_eq!(a.code, FlatBasicEnumCode::A);
   assert_eq!(a.description, "A");
 }
 
 #[test]
 fn test_flat_enum_from() {
-  let a = FlatEnum::from(Enum::A);
-  assert_eq!(a.code, FlatEnumCode::A);
+  let a = FlatBasicEnum::from(BasicEnum::A);
+  assert_eq!(a.code, FlatBasicEnumCode::A);
   assert_eq!(a.description, "A");
 
-  let b = FlatEnum::from(Enum::B("bee".to_owned()));
-  assert_eq!(b.code, FlatEnumCode::B);
+  let b = FlatBasicEnum::from(BasicEnum::B("bee".to_owned()));
+  assert_eq!(b.code, FlatBasicEnumCode::B);
   assert_eq!(b.description, r#"B("bee")"#);
 
-  let c = FlatEnum::from(Enum::C { a: "c".to_owned() });
-  assert_eq!(c.code, FlatEnumCode::C);
+  let c = FlatBasicEnum::from(BasicEnum::C { a: "c".to_owned() });
+  assert_eq!(c.code, FlatBasicEnumCode::C);
   assert_eq!(c.description, r#"C { a: "c" }"#);
 
-  let d = FlatEnum::from(Enum::D {
+  let d = FlatBasicEnum::from(BasicEnum::D {
     a: "d".to_owned(),
     b: 123,
   });
-  assert_eq!(d.code, FlatEnumCode::D);
+  assert_eq!(d.code, FlatBasicEnumCode::D);
   assert_eq!(d.description, r#"D { a: "d", b: 123 }"#);
 }
 
 #[test]
 fn test_to_flat_enum() {
-  let a = Enum::A.to_flat_enum();
-  assert_eq!(a.code, FlatEnumCode::A);
+  let a = BasicEnum::A.into_flat_enum();
+  assert_eq!(a.code, FlatBasicEnumCode::A);
   assert_eq!(a.description, "A");
 
-  let b = Enum::B("bee".to_owned()).to_flat_enum();
-  assert_eq!(b.code, FlatEnumCode::B);
+  let b = BasicEnum::B("bee".to_owned()).into_flat_enum();
+  assert_eq!(b.code, FlatBasicEnumCode::B);
   assert_eq!(b.description, r#"B("bee")"#);
 
-  let c = Enum::C { a: "c".to_owned() }.to_flat_enum();
-  assert_eq!(c.code, FlatEnumCode::C);
+  let c = BasicEnum::C { a: "c".to_owned() }.into_flat_enum();
+  assert_eq!(c.code, FlatBasicEnumCode::C);
   assert_eq!(c.description, r#"C { a: "c" }"#);
 
-  let d = Enum::D {
+  let d = BasicEnum::D {
     a: "d".to_owned(),
     b: 123,
   }
-  .to_flat_enum();
-  assert_eq!(d.code, FlatEnumCode::D);
+  .into_flat_enum();
+  assert_eq!(d.code, FlatBasicEnumCode::D);
   assert_eq!(d.description, r#"D { a: "d", b: 123 }"#);
 }