Create JsonWebKeyError

Signed-off-by: Patrik Stas <[email protected]>

Author: Patrik-Stas

did_core/did_doc/src/schema/types/jsonwebkey.rs

@@ -3,9 +3,28 @@ use std::{
     fmt::{self, Display, Formatter},
     str::FromStr,
 };
+use std::error::Error;
 
 use serde::{Deserialize, Serialize};
 use serde_json::Value;
+use thiserror::Error;
+
+#[derive(Debug, Error)]
+pub struct JsonWebKeyError {
+    reason: &'static str,
+    #[source]
+    source: Box<dyn Error + Sync + Send>,
+}
+
+impl Display for JsonWebKeyError {
+    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
+        write!(
+            f,
+            "JsonWebKeyError, reason: {}, source: {}",
+            self.reason, self.source
+        )
+    }
+}
 
 #[derive(Serialize, Deserialize, Clone, Debug, PartialEq)]
 // TODO: Introduce proper custom type
@@ -23,17 +42,23 @@ pub struct JsonWebKey {
 
 impl JsonWebKey {
     // todo: More future-proof way would be creating custom error type, but seems as overkill atm?
-    pub fn new(jwk: &str) -> Result<Self, serde_json::Error> {
-        serde_json::from_str(jwk)
+    pub fn new(jwk: &str) -> Result<Self, JsonWebKeyError> {
+        serde_json::from_str(jwk).map_err(|err| JsonWebKeyError {
+            reason: "Parsing JWK failed",
+            source: Box::new(err),
+        })
     }
 
-    pub fn to_vec(&self) -> Result<Vec<u8>, serde_json::Error> {
-        serde_json::to_vec(self)
+    pub fn to_vec(&self) -> Result<Vec<u8>, JsonWebKeyError> {
+        serde_json::to_vec(self).map_err(|err| JsonWebKeyError {
+            reason: "Serializing JWK to vector failed",
+            source: Box::new(err),
+        })
     }
 }
 
 impl FromStr for JsonWebKey {
-    type Err = serde_json::Error;
+    type Err = JsonWebKeyError;
 
     fn from_str(s: &str) -> Result<Self, Self::Err> {
         Self::new(s)

did_core/did_doc/src/schema/types/multibase.rs

@@ -10,7 +10,7 @@ use thiserror::Error;
 
 #[derive(Debug, Error)]
 pub struct MultibaseWrapperError {
-    reason: String,
+    reason: &'static str,
     #[source]
     source: Box<dyn Error + Sync + Send>,
 }
@@ -35,7 +35,7 @@ pub struct Multibase {
 impl Multibase {
     pub fn new(multibase: String) -> Result<Self, MultibaseWrapperError> {
         let (base, bytes) = decode(multibase).map_err(|err| MultibaseWrapperError {
-            reason: format!("Decoding multibase value failed"),
+            reason: "Decoding multibase value failed",
             source: Box::new(err),
         })?;
         Ok(Self { base, bytes })
@@ -136,7 +136,7 @@ mod tests {
     #[test]
     fn test_multibase_from_str_invalid() {
         let multibase = "invalidmultibasekey".parse::<Multibase>();
-        let err = multibase.err().expect("Error was expected.");
+        let err = multibase.expect_err("Error was expected.");
         assert!(err
             .source()
             .expect("Error was expected to has source set up.")

did_core/did_doc/src/schema/verification_method/error.rs

@@ -1,4 +1,5 @@
 use thiserror::Error;
+use crate::schema::types::jsonwebkey::JsonWebKeyError;
 
 use crate::schema::types::multibase::MultibaseWrapperError;
 
@@ -17,7 +18,7 @@ pub enum KeyDecodingError {
     #[error("Hex decoding error: ${0}")]
     HexDecodeError(hex::FromHexError),
     #[error("Jwk decoding error: ${0}")]
-    JwkDecodeError(serde_json::Error),
+    JwkDecodeError(JsonWebKeyError),
     #[error("Multibase decoding error ${0}")]
     MultibaseError(MultibaseWrapperError),
 }