feat(rust/signed-doc): Add codegen marco for ContentTypeRule (#526)

* initial

* chore: rename field

* chore: rename field

* chore: rename field

* feat: minor tryinto

* feat: full implementation

* chore: minor

* chore: merge clean up

* refactor: new structure

* chore: minor rename

* feat: content type from spec

* chore: fix pascalcase

* chore: minor

* chore: minor

* chore: minor comments

* chore: update changes

* chore: fmtfix

* fix: comment

Author: apskhem

rust/catalyst-signed-doc-macro/Cargo.toml

@@ -19,4 +19,5 @@ quote = "1.0"
 proc-macro2 = "1.0"
 serde_json = "1.0.142"
 anyhow = "1.0.99"
+Inflector = "0.11.4"
 serde = { version = "1.0.219", features = ["derive"] }

rust/catalyst-signed-doc-macro/src/rules/content_type.rs

@@ -0,0 +1,51 @@
+//! `ContentTypeRule` generation
+
+use std::collections::HashMap;
+
+use proc_macro2::TokenStream;
+use quote::quote;
+
+use crate::signed_doc_spec::{self, ContentTypeSpec, ContentTypeTemplate, IsRequired};
+
+/// Generating `ContentTypeRule` instantiation
+pub(crate) fn into_rule(
+    content_types: &HashMap<ContentTypeTemplate, ContentTypeSpec>,
+    field: &signed_doc_spec::content_type::ContentType,
+) -> anyhow::Result<TokenStream> {
+    let is_field_empty = field.value.is_none()
+        || field
+            .value
+            .as_ref()
+            .is_some_and(std::string::String::is_empty);
+
+    if matches!(field.required, IsRequired::Excluded) {
+        anyhow::ensure!(
+            is_field_empty,
+            "'value' field must not exist when 'required' is 'excluded'"
+        );
+
+        return Ok(quote! {
+            crate::validator::rules::ContentTypeRule::NotSpecified
+        });
+    }
+
+    if matches!(field.required, IsRequired::Yes) {
+        anyhow::ensure!(!is_field_empty, "'value' field must exist");
+    }
+
+    let Some(value) = &field.value else {
+        anyhow::bail!("'value' field must exist");
+    };
+
+    let template = ContentTypeTemplate(value.clone());
+    let Some(_) = content_types.get(&template) else {
+        return Err(anyhow::anyhow!("Unsupported Content Type: {}", value));
+    };
+    let ident = template.ident();
+
+    Ok(quote! {
+        crate::validator::rules::ContentTypeRule::Specified {
+            exp: ContentType::#ident,
+        }
+    })
+}

rust/catalyst-signed-doc-macro/src/rules/mod.rs

@@ -1,5 +1,6 @@
 //! `catalyst_signed_documents_rules!` macro implementation
 
+pub(crate) mod content_type;
 pub(crate) mod doc_ref;
 
 use proc_macro2::TokenStream;
@@ -15,13 +16,15 @@ pub(crate) fn catalyst_signed_documents_rules_impl() -> anyhow::Result<TokenStre
     for (doc_name, doc_spec) in spec.docs {
         let const_type_name_ident = doc_name.ident();
 
+        let content_type_rule =
+            content_type::into_rule(&spec.content_types, &doc_spec.headers.content_type)?;
         let ref_rule = doc_ref::ref_rule(&doc_spec.metadata.doc_ref)?;
         // TODO: implement a proper initialization for all specific validation rules
         let rules = quote! {
             crate::validator::rules::Rules {
                 id: crate::validator::rules::IdRule,
                 ver: crate::validator::rules::VerRule,
-                content_type: crate::validator::rules::ContentTypeRule::NotSpecified,
+                content_type: #content_type_rule,
                 content_encoding: crate::validator::rules::ContentEncodingRule::Specified {
                     exp: ContentEncoding::Brotli,
                     optional: false,

rust/catalyst-signed-doc-macro/src/signed_doc_spec/content_type.rs

@@ -0,0 +1,9 @@
+//! `signed_doc.json` headers content type field JSON definition
+
+/// `signed_doc.json` "content type" field JSON object
+#[derive(serde::Deserialize)]
+#[allow(clippy::missing_docs_in_private_items)]
+pub(crate) struct ContentType {
+    pub(crate) required: super::IsRequired,
+    pub(crate) value: Option<String>,
+}

rust/catalyst-signed-doc-macro/src/signed_doc_spec/mod.rs

@@ -1,19 +1,73 @@
 //! Catalyst Signed Document spec type
 
+// cspell: words pascalcase
+
+pub(crate) mod content_type;
 pub(crate) mod doc_ref;
 
 use std::{collections::HashMap, ops::Deref};
 
+use inflector::cases::pascalcase::to_pascal_case;
 use proc_macro2::Ident;
 use quote::format_ident;
 
 /// Catalyst Signed Document spec representation struct
 #[derive(serde::Deserialize)]
 pub(crate) struct CatalystSignedDocSpec {
+    /// A collection of document's supported content types
+    #[serde(rename = "contentTypes")]
+    #[allow(dead_code)]
+    pub(crate) content_types: HashMap<ContentTypeTemplate, ContentTypeSpec>,
     /// A collection of document's specs
     pub(crate) docs: HashMap<DocumentName, DocSpec>,
 }
 
+// A thin wrapper over the RFC2046 content type strings.
+#[derive(serde::Deserialize, PartialEq, Eq, Hash)]
+pub(crate) struct ContentTypeTemplate(pub(crate) String);
+
+impl ContentTypeTemplate {
+    /// returns a content type template as a `Ident` in the following form.
+    ///
+    /// text/css; charset=utf-8; template=handlebars
+    /// => `CssHandlebars`
+    ///
+    /// text/css; charset=utf-8
+    /// => `Css`
+    pub(crate) fn ident(&self) -> Ident {
+        let raw = self.0.as_str();
+
+        // split into parts like "text/css; charset=utf-8; template=handlebars"
+        let mut parts = raw.split(';').map(str::trim);
+
+        // first part is "type/subtype"
+        let first = parts.next().unwrap_or_default(); // e.g. "text/css"
+        let subtype = first.split('/').nth(1).unwrap_or_default(); // "css"
+
+        // look for "template=..."
+        let template = parts
+            .find_map(|p| p.strip_prefix("template="))
+            .map(to_pascal_case);
+
+        // build PascalCase
+        let mut ident = String::new();
+        ident.push_str(&to_pascal_case(subtype));
+        if let Some(t) = template {
+            ident.push_str(&t);
+        }
+
+        format_ident!("{}", ident)
+    }
+}
+
+/// Catalyst Signed Document supported content type declaration struct
+#[derive(serde::Deserialize)]
+pub(crate) struct ContentTypeSpec {
+    /// CoAP Content-Formats
+    #[allow(dead_code)]
+    coap_type: Option<u32>,
+}
+
 // A thin wrapper over the string document name values
 #[derive(serde::Deserialize, PartialEq, Eq, Hash)]
 pub(crate) struct DocumentName(String);
@@ -44,7 +98,8 @@ pub(crate) struct DocSpec {
     /// Document type UUID v4 value
     #[serde(rename = "type")]
     pub(crate) doc_type: String,
-
+    /// `headers` field
+    pub(crate) headers: Headers,
     /// Document type metadata definitions
     pub(crate) metadata: Metadata,
 }
@@ -57,6 +112,14 @@ pub(crate) struct Metadata {
     pub(crate) doc_ref: doc_ref::Ref,
 }
 
+/// Document's metadata fields definition
+#[derive(serde::Deserialize)]
+#[allow(clippy::missing_docs_in_private_items)]
+pub(crate) struct Headers {
+    #[serde(rename = "content type")]
+    pub(crate) content_type: content_type::ContentType,
+}
+
 /// "required" field definition
 #[derive(serde::Deserialize)]
 #[serde(rename_all = "lowercase")]
@@ -103,7 +166,8 @@ impl CatalystSignedDocSpec {
     // #[allow(dependency_on_unit_never_type_fallback)]
     pub(crate) fn load_signed_doc_spec() -> anyhow::Result<CatalystSignedDocSpec> {
         let signed_doc_str = include_str!("../../../../specs/signed_doc.json");
-        let signed_doc_spec = serde_json::from_str(signed_doc_str)?;
+        let signed_doc_spec = serde_json::from_str(signed_doc_str)
+            .map_err(|e| anyhow::anyhow!("Invalid Catalyst Signed Documents JSON Spec: {e}"))?;
         Ok(signed_doc_spec)
     }
 }

rust/signed_doc/src/metadata/content_type.rs

@@ -16,9 +16,9 @@ pub enum ContentType {
     /// `application/json`
     #[strum(to_string = "application/json")]
     Json,
-    /// `application/json+schema`
-    #[strum(to_string = "application/json+schema")]
-    JsonSchema,
+    /// `application/schema+json`
+    #[strum(to_string = "application/schema+json")]
+    SchemaJson,
     /// `text/css; charset=utf-8`
     #[strum(to_string = "text/css; charset=utf-8")]
     Css,
@@ -53,7 +53,7 @@ impl FromStr for ContentType {
             "application/cbor" => Ok(Self::Cbor),
             "application/cddl" => Ok(Self::Cddl),
             "application/json" => Ok(Self::Json),
-            "application/json+schema" => Ok(Self::JsonSchema),
+            "application/schema+json" => Ok(Self::SchemaJson),
             "text/css; charset=utf-8" => Ok(Self::Css),
             "text/css; charset=utf-8; template=handlebars" => Ok(Self::CssHandlebars),
             "text/html; charset=utf-8" => Ok(Self::Html),
@@ -162,8 +162,8 @@ mod tests {
         "application/json"
     )]
     #[test_case(
-        ("application/json+schema", ContentType::JsonSchema);
-        "application/json+schema"
+        ("application/schema+json", ContentType::SchemaJson);
+        "application/schema+json"
     )]
     #[test_case(
         ("text/css; charset=utf-8", ContentType::Css);

rust/signed_doc/src/validator/rules/content_type.rs

@@ -11,6 +11,7 @@ pub(crate) enum ContentTypeRule {
         exp: ContentType,
     },
     /// Content Type field must not be present in the document.
+    #[allow(dead_code)]
     NotSpecified,
 }
 
@@ -92,7 +93,7 @@ impl ContentTypeRule {
                     }
                 },
                 ContentType::Cddl
-                | ContentType::JsonSchema
+                | ContentType::SchemaJson
                 | ContentType::Css
                 | ContentType::CssHandlebars
                 | ContentType::Html

rust/signed_doc/src/validator/rules/template.rs

@@ -49,7 +49,7 @@ impl TemplateRule {
                     return false;
                 };
                 match template_content_type {
-                    ContentType::Json | ContentType::JsonSchema => {
+                    ContentType::Json | ContentType::SchemaJson => {
                         templated_json_schema_check(doc, template_doc)
                     },
                     ContentType::Cddl