wip

Author: Mr-Leshiy

rust/catalyst-signed-doc-spec/src/metadata/mod.rs

@@ -1,6 +1,7 @@
 //! `metadata` field definition
 
 pub mod doc_ref;
+pub mod parameters;
 pub mod reply;
 pub mod template;
 

rust/catalyst-signed-doc-spec/src/metadata/parameters.rs

@@ -0,0 +1,17 @@
+//! `signed_doc.json` "parameters" field JSON definition
+
+use std::ops::Deref;
+
+use crate::metadata::doc_ref::Ref;
+
+/// `signed_doc.json` "parameters" field JSON object
+#[derive(serde::Deserialize)]
+pub struct Parameters(pub Ref);
+
+impl Deref for Parameters {
+    type Target = Ref;
+
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}

rust/catalyst-signed-doc-spec/src/metadata/template.rs

@@ -1,13 +1,17 @@
 //! `signed_doc.json` "template" field JSON definition
 
-use crate::{is_required::IsRequired, DocumentName};
+use std::ops::Deref;
+
+use crate::metadata::doc_ref::Ref;
 
 /// `signed_doc.json` "template" field JSON object
 #[derive(serde::Deserialize)]
-#[allow(clippy::missing_docs_in_private_items, dead_code)]
-pub struct Template {
-    pub required: IsRequired,
-    #[serde(rename = "type")]
-    pub doc_type: Option<DocumentName>,
-    pub multiple: Option<bool>,
+pub struct Template(pub Ref);
+
+impl Deref for Template {
+    type Target = Ref;
+
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
 }

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

@@ -28,19 +28,23 @@ impl RefRule {
     /// Generating `RefRule` from specs
     pub(crate) fn new(
         docs: &HashMap<catalyst_signed_doc_spec::DocumentName, catalyst_signed_doc_spec::DocSpec>,
-        ref_spec: &catalyst_signed_doc_spec::metadata::doc_ref::Ref,
+        spec: &catalyst_signed_doc_spec::metadata::doc_ref::Ref,
     ) -> anyhow::Result<Self> {
-        let optional = match ref_spec.required {
+        let optional = match spec.required {
             catalyst_signed_doc_spec::is_required::IsRequired::Yes => false,
             catalyst_signed_doc_spec::is_required::IsRequired::Optional => true,
             catalyst_signed_doc_spec::is_required::IsRequired::Excluded => {
+                anyhow::ensure!(
+                    spec.doc_type.is_empty() && spec.multiple.is_none(),
+                     "'type' and 'multiple' fields could not been specified when 'required' is 'excluded' for 'ref' metadata definition"
+                );
                 return Ok(Self::NotSpecified);
             },
         };
 
-        anyhow::ensure!(!ref_spec.doc_type.is_empty(), "'type' field should exists and has at least one entry for the required 'ref' metadata definition");
+        anyhow::ensure!(!spec.doc_type.is_empty(), "'type' field should exists and has at least one entry for the required 'ref' metadata definition");
 
-        let exp_ref_types = ref_spec.doc_type.iter().try_fold(
+        let exp_ref_types = spec.doc_type.iter().try_fold(
             Vec::new(),
             |mut res, doc_name| -> anyhow::Result<_> {
                 let docs_spec = docs.get(doc_name).ok_or(anyhow::anyhow!(
@@ -51,7 +55,7 @@ impl RefRule {
             },
         )?;
 
-        let multiple = ref_spec.multiple.ok_or(anyhow::anyhow!(
+        let multiple = spec.multiple.ok_or(anyhow::anyhow!(
             "'multiple' field should exists for the required 'ref' metadata definition"
         ))?;
 

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

@@ -35,18 +35,21 @@ impl ReplyRule {
             IsRequired::Yes => false,
             IsRequired::Optional => true,
             IsRequired::Excluded => {
+                anyhow::ensure!(
+                    spec.doc_type.is_empty() && spec.multiple.is_none(),
+                    "'type' and 'multiple' fields could not been specified when 'required' is 'excluded' for 'template'  metadata definition"
+                );
                 return Ok(Self::NotSpecified);
             },
         };
 
-        anyhow::ensure!(spec.doc_type.len() == 1, "'type' field should exists and has only one entry for the required 'reply' metadata definition");
         anyhow::ensure!(
             spec.multiple.is_some_and(|v| !v),
             "'multiple' field should be only set to false for the required 'reply' metadata definition"
         );
 
-        let doc_name = spec.doc_type.first().ok_or(anyhow::anyhow!("'type' field should exists and has only one entry for the required 'reply' metadata definition"))?;
-        let docs_spec = docs.get(doc_name).ok_or(anyhow::anyhow!(
+        let doc_name = &<&[DocumentName; 1]>::try_from(spec.doc_type.as_slice()).map_err(|_| anyhow::anyhow!("'type' field should exists and has only one entry for the required 'reply' metadata definition"))?[0];
+        let docs_spec = docs.get(&doc_name).ok_or(anyhow::anyhow!(
             "cannot find a document definition {doc_name}"
         ))?;
         let allowed_type = docs_spec.doc_type.as_str().parse()?;

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

@@ -35,25 +35,23 @@ impl TemplateRule {
     ) -> anyhow::Result<Self> {
         if let IsRequired::Excluded = spec.required {
             anyhow::ensure!(
-            spec.doc_type.is_none() && spec.multiple.is_none(),
-            "'type' and 'multiple' fields could not been specified when 'required' is 'excluded' for 'template'  metadata definition"
-        );
+                spec.doc_type.is_empty() && spec.multiple.is_none(),
+                "'type' and 'multiple' fields could not been specified when 'required' is 'excluded' for 'template'  metadata definition"
+            );
             return Ok(Self::NotSpecified);
         }
 
         anyhow::ensure!(
             spec.multiple.is_some_and(|v| !v),
-            "'multiple' must be `false` for 'template' metadata definition"
+            "'multiple' field should be only set to false for the required 'reply' metadata definition"
         );
         anyhow::ensure!(
             spec.required != IsRequired::Optional,
-            "'required' field cannot been 'optional' for 'template'  metadata definition"
+            "'required' field cannot been 'optional' for 'template' metadata definition"
         );
 
-        let doc_name = spec.doc_type.as_ref().ok_or(anyhow::anyhow!(
-            "'type' field should exists for the required 'template' metadata definition"
-        ))?;
-        let docs_spec = docs.get(doc_name).ok_or(anyhow::anyhow!(
+        let doc_name = &<&[DocumentName; 1]>::try_from(spec.doc_type.as_slice()).map_err(|_| anyhow::anyhow!("'type' field should exists and has only one entry for the required 'reply' metadata definition"))?[0];
+        let docs_spec = docs.get(&doc_name).ok_or(anyhow::anyhow!(
             "cannot find a document definition {doc_name}"
         ))?;
         let allowed_type = docs_spec.doc_type.as_str().parse()?;