fix(rust/signed_doc): ser/de for ContentType and ContentEncoding.

* update example to build docs from metadata file

Author: saibatizoku

rust/signed_doc/examples/mk_signed_doc.rs

@@ -9,7 +9,7 @@ use std::{
 };
 
 use clap::Parser;
-use coset::CborSerializable;
+use coset::{iana::CoapContentFormat, CborSerializable};
 use ed25519_dalek::{
     ed25519::signature::Signer,
     pkcs8::{DecodePrivateKey, DecodePublicKey},
@@ -121,6 +121,7 @@ impl Cli {
                 let json_doc = load_json_from_file(&doc)?;
                 let json_meta = load_json_from_file(&meta)
                     .map_err(|e| anyhow::anyhow!("Failed to load metadata from file: {e}"))?;
+                println!("{json_meta}");
                 validate_json(&json_doc, &doc_schema)?;
                 let compressed_doc = brotli_compress_json(&json_doc)?;
                 let empty_cose_sign = build_empty_cose_doc(compressed_doc, &json_meta);
@@ -194,7 +195,7 @@ fn brotli_decompress_json(mut doc_bytes: &[u8]) -> anyhow::Result<serde_json::Va
 
 fn cose_protected_header() -> coset::Header {
     coset::HeaderBuilder::new()
-        .content_format(coset::iana::CoapContentFormat::Json)
+        .content_format(CoapContentFormat::Json)
         .text_value(
             CONTENT_ENCODING_KEY.to_string(),
             CONTENT_ENCODING_VALUE.to_string().into(),
@@ -203,7 +204,19 @@ fn cose_protected_header() -> coset::Header {
 }
 
 fn build_empty_cose_doc(doc_bytes: Vec<u8>, meta: &Metadata) -> coset::CoseSign {
-    let mut protected_header = cose_protected_header();
+    let mut builder = coset::HeaderBuilder::new();
+
+    if let Some(content_type) = meta.content_type() {
+        builder = builder.content_format(CoapContentFormat::from(content_type));
+    }
+
+    if let Some(content_encoding) = meta.content_encoding() {
+        builder = builder.text_value(
+            CONTENT_ENCODING_KEY.to_string(),
+            format!("{content_encoding}").into(),
+        );
+    }
+    let mut protected_header = builder.build();
 
     protected_header.rest.push((
         coset::Label::Text("type".to_string()),

rust/signed_doc/meta.schema.json

@@ -97,6 +97,19 @@
         },
         "section": {
             "type": "string"
+        },
+        "content-type": {
+            "type": "string",
+            "examples": [
+                "json",
+                "cbor"
+            ]
+        },
+        "content-encoding": {
+            "type": "string",
+            "examples": [
+                "br"
+            ]
         }
     },
     "required": [

rust/signed_doc/src/metadata/content_encoding.rs

@@ -1,30 +1,56 @@
 //! Document Payload Content Encoding.
 
+use std::{
+    fmt::{Display, Formatter},
+    str::FromStr,
+};
+
+use serde::{de, Deserialize, Deserializer};
+
 /// Catalyst Signed Document Content Encoding Key.
 const CONTENT_ENCODING_KEY: &str = "Content-Encoding";
 
 /// IANA `CoAP` Content Encoding.
-#[derive(Debug, serde::Deserialize)]
-#[serde(untagged)]
+#[derive(Copy, Clone, Debug, PartialEq, Eq)]
 pub enum ContentEncoding {
     /// Brotli compression.format.
-    #[serde(rename = "br")]
     Brotli,
 }
 
+impl Display for ContentEncoding {
+    fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), std::fmt::Error> {
+        match self {
+            Self::Brotli => write!(f, "br"),
+        }
+    }
+}
+
+impl FromStr for ContentEncoding {
+    type Err = anyhow::Error;
+
+    fn from_str(encoding: &str) -> Result<Self, Self::Err> {
+        match encoding {
+            "br" => Ok(ContentEncoding::Brotli),
+            _ => anyhow::bail!("Unsupported Content Encoding: {encoding:?}"),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for ContentEncoding {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where D: Deserializer<'de> {
+        let s = String::deserialize(deserializer)?;
+        FromStr::from_str(&s).map_err(de::Error::custom)
+    }
+}
+
 impl TryFrom<&coset::cbor::Value> for ContentEncoding {
     type Error = anyhow::Error;
 
-    #[allow(clippy::todo)]
     fn try_from(val: &coset::cbor::Value) -> anyhow::Result<ContentEncoding> {
         match val.as_text() {
-            Some(encoding) => {
-                match encoding.to_string().to_lowercase().as_ref() {
-                    "br" => Ok(ContentEncoding::Brotli),
-                    _ => anyhow::bail!("Unsupported Content Encoding: {encoding}"),
-                }
-            },
-            _ => {
+            Some(encoding) => encoding.parse(),
+            None => {
                 anyhow::bail!("Expected Content Encoding to be a string");
             },
         }

rust/signed_doc/src/metadata/content_type.rs

@@ -1,24 +1,69 @@
 //! Document Payload Content Type.
 
+use std::{
+    fmt::{Display, Formatter},
+    str::FromStr,
+};
+
+use coset::iana::CoapContentFormat;
+use serde::{de, Deserialize, Deserializer};
+
 /// Payload Content Type.
-#[derive(Debug, serde::Deserialize)]
-#[serde(untagged, rename_all_fields = "lowercase")]
+#[derive(Copy, Clone, Debug)]
 pub enum ContentType {
     /// 'application/cbor'
     Cbor,
     /// 'application/json'
     Json,
 }
 
+impl Display for ContentType {
+    fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), std::fmt::Error> {
+        match self {
+            Self::Cbor => write!(f, "cbor"),
+            Self::Json => write!(f, "json"),
+        }
+    }
+}
+
+impl FromStr for ContentType {
+    type Err = anyhow::Error;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        match s {
+            "cbor" => Ok(Self::Cbor),
+            "json" => Ok(Self::Json),
+            _ => anyhow::bail!("Unsupported Content Type: {s:?}"),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for ContentType {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where D: Deserializer<'de> {
+        let s = String::deserialize(deserializer)?;
+        FromStr::from_str(&s).map_err(de::Error::custom)
+    }
+}
+
+impl From<ContentType> for CoapContentFormat {
+    fn from(value: ContentType) -> Self {
+        match value {
+            ContentType::Cbor => Self::Cbor,
+            ContentType::Json => Self::Json,
+        }
+    }
+}
+
 impl TryFrom<&coset::ContentType> for ContentType {
     type Error = anyhow::Error;
 
     fn try_from(value: &coset::ContentType) -> Result<Self, Self::Error> {
-        use coset::iana::CoapContentFormat as Format;
-        match value {
-            coset::ContentType::Assigned(Format::Json) => Ok(ContentType::Json),
-            coset::ContentType::Assigned(Format::Cbor) => Ok(ContentType::Cbor),
+        let content_type = match value {
+            coset::ContentType::Assigned(CoapContentFormat::Json) => ContentType::Json,
+            coset::ContentType::Assigned(CoapContentFormat::Cbor) => ContentType::Cbor,
             _ => anyhow::bail!("Unsupported Content Type {value:?}"),
-        }
+        };
+        Ok(content_type)
     }
 }

rust/signed_doc/src/metadata/mod.rs

@@ -42,8 +42,10 @@ pub struct Metadata {
     /// Reference to the document section.
     section: Option<String>,
     /// Document Payload Content Type.
+    #[serde(default, rename = "content-type")]
     content_type: Option<ContentType>,
     /// Document Payload Content Encoding.
+    #[serde(default, rename = "content-encoding")]
     content_encoding: Option<ContentEncoding>,
     /// Metadata Content Errors
     #[serde(skip)]
@@ -105,10 +107,16 @@ impl Metadata {
         &self.content_errors
     }
 
-    /// Return
+    /// Returns the Document Content Type, if any.
     #[must_use]
-    pub fn content_type(&self) -> &Option<ContentType> {
-        &self.content_type
+    pub fn content_type(&self) -> Option<ContentType> {
+        self.content_type
+    }
+
+    /// Returns the Document Content Encoding, if any.
+    #[must_use]
+    pub fn content_encoding(&self) -> Option<ContentEncoding> {
+        self.content_encoding
     }
 }
 
@@ -194,11 +202,10 @@ impl From<&coset::ProtectedHeader> for Metadata {
                     },
                 }
             },
-            _ => {
-                errors.push(
-                    "Invalid COSE document protected header '{CONTENT_ENCODING_KEY}' label"
-                        .to_string(),
-                );
+            None => {
+                errors.push(format!(
+                    "Invalid COSE document protected header '{CONTENT_ENCODING_KEY}' is missing"
+                ));
             },
         }
         match cose_protected_header_find(protected, "type") {