refactor Metadata decoding

Author: Mr-Leshiy

rust/signed_doc/src/metadata/content_type.rs

@@ -17,12 +17,6 @@ pub enum ContentType {
     Json,
 }
 
-impl Default for ContentType {
-    fn default() -> Self {
-        Self::Json
-    }
-}
-
 impl Display for ContentType {
     fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), std::fmt::Error> {
         match self {

rust/signed_doc/src/metadata/document_id.rs

@@ -9,11 +9,6 @@ use super::UuidV7;
 pub struct DocumentId(UuidV7);
 
 impl DocumentId {
-    /// Generates a zeroed out `UUIDv7` that can never be valid.
-    pub fn invalid() -> Self {
-        Self(UuidV7::invalid())
-    }
-
     /// Returns the `uuid::Uuid` type.
     #[must_use]
     pub fn uuid(&self) -> uuid::Uuid {

rust/signed_doc/src/metadata/document_type.rs

@@ -9,11 +9,6 @@ use super::UuidV4;
 pub struct DocumentType(UuidV4);
 
 impl DocumentType {
-    /// Generates a zeroed out `UUIDv4` that can never be valid.
-    pub fn invalid() -> Self {
-        Self(UuidV4::invalid())
-    }
-
     /// Returns the `uuid::Uuid` type.
     #[must_use]
     pub fn uuid(&self) -> uuid::Uuid {

rust/signed_doc/src/metadata/document_version.rs

@@ -8,11 +8,6 @@ use super::UuidV7;
 pub struct DocumentVersion(UuidV7);
 
 impl DocumentVersion {
-    /// Generates a zeroed out `UUIDv7` that can never be valid.
-    pub fn invalid() -> Self {
-        Self(UuidV7::invalid())
-    }
-
     /// Returns the `uuid::Uuid` type.
     #[must_use]
     pub fn uuid(&self) -> uuid::Uuid {

rust/signed_doc/src/metadata/mod.rs

@@ -35,10 +35,10 @@ pub struct Metadata {
     /// Document Version `UUIDv7`.
     ver: DocumentVersion,
     /// Document Payload Content Type.
-    #[serde(default, rename = "content-type")]
+    #[serde(rename = "content-type")]
     content_type: ContentType,
     /// Document Payload Content Encoding.
-    #[serde(default, rename = "content-encoding")]
+    #[serde(rename = "content-encoding")]
     content_encoding: Option<ContentEncoding>,
     /// Additional Metadata Fields.
     #[serde(flatten)]
@@ -90,131 +90,136 @@ impl Display for Metadata {
     }
 }
 
-impl Default for Metadata {
-    fn default() -> Self {
-        Self {
-            doc_type: DocumentType::invalid(),
-            id: DocumentId::invalid(),
-            ver: DocumentVersion::invalid(),
-            content_type: ContentType::default(),
-            content_encoding: None,
-            extra: AdditionalFields::default(),
-        }
-    }
-}
-
 impl TryFrom<&coset::ProtectedHeader> for Metadata {
     type Error = crate::error::Error;
 
     #[allow(clippy::too_many_lines)]
     fn try_from(protected: &coset::ProtectedHeader) -> Result<Self, Self::Error> {
-        let mut metadata = Metadata::default();
         let mut errors = Vec::new();
 
-        match protected.header.content_type.as_ref() {
-            Some(iana_content_type) => {
-                match ContentType::try_from(iana_content_type) {
-                    Ok(content_type) => metadata.content_type = content_type,
-                    Err(e) => {
-                        errors.push(anyhow!("Invalid Document Content-Type: {e}"));
-                    },
-                }
-            },
-            None => {
-                errors.push(anyhow!(
-                    "COSE document protected header `content-type` field is missing"
-                ));
-            },
+        let content_type = protected.header.content_type.as_ref().and_then(|value| {
+            ContentType::try_from(value).map_or_else(
+                |e| {
+                    errors.push(anyhow!("Invalid Document Content-Type: {e}"));
+                    None
+                },
+                Some,
+            )
+        });
+
+        if content_type.is_none() {
+            errors.push(anyhow!(
+                "Invalid COSE protected header, missing Content-Type field"
+            ));
         }
 
-        if let Some(value) = cose_protected_header_find(
-            protected,
-            |key| matches!(key, coset::Label::Text(label) if label.eq_ignore_ascii_case(CONTENT_ENCODING_KEY)),
-        ) {
-            match ContentEncoding::try_from(value) {
-                Ok(encoding) => {
-                    metadata.content_encoding = Some(encoding);
-                },
-                Err(e) => {
-                    errors.push(anyhow!("Invalid Document Content Encoding: {e}"));
-                },
-            }
-        } else {
+        let content_encoding = cose_protected_header_find(protected, |key| matches!(key, coset::Label::Text(label) if label.eq_ignore_ascii_case(CONTENT_ENCODING_KEY)),
+            )
+            .and_then(|value| {
+                ContentEncoding::try_from(value).map_or_else(
+                    |e| {
+                        errors.push(anyhow!("Invalid Document Content Encoding: {e}"));
+                        None
+                    },
+                    Some,
+                )
+            });
+
+        if content_encoding.is_none() {
             errors.push(anyhow!(
-                "Invalid COSE document protected header '{CONTENT_ENCODING_KEY}' is missing"
+                "Invalid COSE protected header, missing Content-Encoding field"
             ));
         }
 
-        if let Some(doc_type) = cose_protected_header_find(protected, |key| {
+        let doc_type = cose_protected_header_find(protected, |key| {
             key == &coset::Label::Text("type".to_string())
-        }) {
-            match UuidV4::try_from(doc_type) {
-                Ok(doc_type_uuid) => {
-                    metadata.doc_type = doc_type_uuid.into();
-                },
-                Err(e) => {
+        })
+        .and_then(|value| {
+            UuidV4::try_from(value).map_or_else(
+                |e| {
                     errors.push(anyhow!("Document `type` is invalid: {e}"));
+                    None
                 },
-            }
-        } else {
+                Some,
+            )
+        });
+
+        if doc_type.is_none() {
             errors.push(anyhow!(
                 "Invalid COSE protected header, missing `type` field"
             ));
         }
 
-        match cose_protected_header_find(protected, |key| {
+        let id = cose_protected_header_find(protected, |key| {
             key == &coset::Label::Text("id".to_string())
-        }) {
-            Some(doc_id) => {
-                match UuidV7::try_from(doc_id) {
-                    Ok(doc_id_uuid) => {
-                        metadata.id = doc_id_uuid.into();
-                    },
-                    Err(e) => {
-                        errors.push(anyhow!("Document `id` is invalid: {e}"));
-                    },
-                }
-            },
-            None => errors.push(anyhow!("Invalid COSE protected header, missing `id` field")),
-        };
+        })
+        .and_then(|value| {
+            UuidV7::try_from(value).map_or_else(
+                |e| {
+                    errors.push(anyhow!("Document `id` is invalid: {e}"));
+                    None
+                },
+                Some,
+            )
+        });
 
-        match cose_protected_header_find(protected, |key| {
+        if id.is_none() {
+            errors.push(anyhow!("Invalid COSE protected header, missing `id` field"));
+        }
+
+        let ver = cose_protected_header_find(protected, |key| {
             key == &coset::Label::Text("ver".to_string())
-        }) {
-            Some(doc_ver) => {
-                match UuidV7::try_from(doc_ver) {
-                    Ok(doc_ver_uuid) => {
-                        if doc_ver_uuid.uuid() < metadata.id.uuid() {
-                            errors.push(anyhow!(
-                            "Document Version {doc_ver_uuid} cannot be smaller than Document ID {}", metadata.id
-                        ));
-                        } else {
-                            metadata.ver = doc_ver_uuid.into();
-                        }
-                    },
-                    Err(e) => {
-                        errors.push(anyhow!(
-                            "Invalid COSE protected header `ver` field, err: {e}"
-                        ));
-                    },
-                }
-            },
-            None => {
-                errors.push(anyhow!(
-                    "Invalid COSE protected header, missing `ver` field"
-                ));
-            },
+        })
+        .and_then(|value| {
+            UuidV7::try_from(value).map_or_else(
+                |e| {
+                    errors.push(anyhow!("Document `ver` is invalid: {e}"));
+                    None
+                },
+                Some,
+            )
+        });
+
+        if ver.is_none() {
+            errors.push(anyhow!(
+                "Invalid COSE protected header, missing `ver` field"
+            ));
         }
 
-        match AdditionalFields::try_from(protected) {
-            Ok(extra) => metadata.extra = extra,
-            Err(e) => errors.extend(e),
-        };
+        let extra = AdditionalFields::try_from(protected).map_or_else(
+            |e| {
+                errors.extend(e);
+                None
+            },
+            Some,
+        );
+
+        match (content_type, content_encoding, id, doc_type, ver, extra) {
+            (
+                Some(content_type),
+                content_encoding,
+                Some(id),
+                Some(doc_type),
+                Some(ver),
+                Some(extra),
+            ) => {
+                if ver < id {
+                    errors.push(anyhow!(
+                        "Document Version {ver} cannot be smaller than Document ID {id}",
+                    ));
+                    return Err(crate::error::Error(errors));
+                }
 
-        if errors.is_empty() {
-            Ok(metadata)
-        } else {
-            Err(errors.into())
+                Ok(Self {
+                    doc_type: doc_type.into(),
+                    id: id.into(),
+                    ver: ver.into(),
+                    content_encoding,
+                    content_type,
+                    extra,
+                })
+            },
+            _ => Err(crate::error::Error(errors)),
         }
     }
 }