feat(rust/signed-doc): Add support for jsonschema draft 2020-12 (#493)

* feat: jsonschema 2020-12

* feat: dynamic version

* feat: jsonschema struct

* chore: lintfix

* chore: fmtfix

* chore: lintfix

* fix: content schema wrapper

* fix: remove access

Author: apskhem

rust/signed_doc/src/validator/json_schema.rs

@@ -0,0 +1,139 @@
+//! A wrapper around a JSON Schema validator.
+
+use std::ops::Deref;
+
+use anyhow::anyhow;
+use jsonschema::{options, Draft, Validator};
+use serde_json::Value;
+
+/// Wrapper around a JSON Schema validator.
+///
+/// Attempts to detect the draft version from the `$schema` field.
+/// If not specified, it tries Draft2020-12 first, then falls back to Draft7.
+/// Returns an error if schema is invalid for both.
+pub(crate) struct JsonSchema(Validator);
+
+impl Deref for JsonSchema {
+    type Target = Validator;
+
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+
+impl TryFrom<&Value> for JsonSchema {
+    type Error = anyhow::Error;
+
+    fn try_from(schema: &Value) -> std::result::Result<Self, Self::Error> {
+        let draft_version = if let Some(schema) = schema.get("$schema").and_then(|s| s.as_str()) {
+            if schema.contains("draft-07") {
+                Some(Draft::Draft7)
+            } else if schema.contains("2020-12") {
+                Some(Draft::Draft202012)
+            } else {
+                None
+            }
+        } else {
+            None
+        };
+
+        if let Some(draft) = draft_version {
+            let validator = options()
+                .with_draft(draft)
+                .build(schema)
+                .map_err(|e| anyhow!("Invalid JSON Schema: {e}"))?;
+
+            Ok(JsonSchema(validator))
+        } else {
+            // if draft not specified or not detectable:
+            // try draft2020-12
+            if let Ok(validator) = options().with_draft(Draft::Draft202012).build(schema) {
+                return Ok(JsonSchema(validator));
+            }
+
+            // fallback to draft7
+            if let Ok(validator) = options().with_draft(Draft::Draft7).build(schema) {
+                return Ok(JsonSchema(validator));
+            }
+
+            Err(anyhow!(
+                "Could not detect draft version and schema is not valid against Draft2020-12 or Draft7"
+            ))
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use serde_json::json;
+
+    use super::*;
+
+    #[test]
+    fn valid_draft7_schema() {
+        let schema = json!({
+            "$schema": "http://json-schema.org/draft-07/schema#",
+            "type": "object",
+            "properties": {
+                "name": { "type": "string" }
+            }
+        });
+
+        let result = JsonSchema::try_from(&schema);
+        assert!(result.is_ok(), "Expected Draft7 schema to be valid");
+    }
+
+    #[test]
+    fn valid_draft2020_12_schema() {
+        let schema = json!({
+            "$schema": "https://json-schema.org/draft/2020-12/schema",
+            "type": "object",
+            "properties": {
+                "age": { "type": "integer" }
+            }
+        });
+
+        let result = JsonSchema::try_from(&schema);
+        assert!(result.is_ok(), "Expected Draft2020-12 schema to be valid");
+    }
+
+    #[test]
+    fn schema_without_draft_should_fallback() {
+        // Valid in both Draft2020-12 and Draft7
+        let schema = json!({
+            "type": "object",
+            "properties": {
+                "id": { "type": "number" }
+            }
+        });
+
+        let result = JsonSchema::try_from(&schema);
+        assert!(
+            result.is_ok(),
+            "Expected schema without $schema to fallback and succeed"
+        );
+    }
+
+    #[test]
+    fn invalid_schema_should_error() {
+        // Invalid schema: "type" is not a valid keyword here
+        let schema = json!({
+            "$schema": "http://json-schema.org/draft-07/schema#",
+            "type": "not-a-valid-type"
+        });
+
+        let result = JsonSchema::try_from(&schema);
+        assert!(
+            result.is_err(),
+            "Expected invalid schema to return an error"
+        );
+    }
+
+    #[test]
+    fn empty_object_schema() {
+        let schema = json!({});
+
+        let result = JsonSchema::try_from(&schema);
+        assert!(result.is_ok());
+    }
+}

rust/signed_doc/src/validator/mod.rs

@@ -1,5 +1,6 @@
 //! Catalyst Signed Documents validation logic
 
+pub(crate) mod json_schema;
 pub(crate) mod rules;
 pub(crate) mod utils;
 
@@ -116,15 +117,15 @@ fn proposal_submission_action_rule() -> Rules {
         CATEGORY_PARAMETERS.clone(),
     ];
 
-    let proposal_action_json_schema = jsonschema::options()
-        .with_draft(jsonschema::Draft::Draft7)
-        .build(
-            &serde_json::from_str(include_str!(
-                "./../../../../specs/definitions/signed_docs/docs/payload_schemas/proposal_submission_action.schema.json"
-            ))
-            .expect("Must be a valid json file"),
-        )
-        .expect("Must be a valid json scheme file");
+    let proposal_action_json_schema_content = &serde_json::from_str(include_str!(
+        "./../../../../specs/definitions/signed_docs/docs/payload_schemas/proposal_submission_action.schema.json"
+    ))
+    .expect("Must be a valid json file");
+
+    let proposal_action_json_schema =
+        json_schema::JsonSchema::try_from(proposal_action_json_schema_content)
+            .expect("Must be a valid json scheme file");
+
     Rules {
         content_type: ContentTypeRule {
             exp: ContentType::Json,

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

@@ -4,15 +4,17 @@ use std::fmt::Write;
 
 use super::doc_ref::referenced_doc_check;
 use crate::{
-    metadata::ContentType, providers::CatalystSignedDocumentProvider,
-    validator::utils::validate_doc_refs, CatalystSignedDocument, DocType,
+    metadata::ContentType,
+    providers::CatalystSignedDocumentProvider,
+    validator::{json_schema, utils::validate_doc_refs},
+    CatalystSignedDocument, DocType,
 };
 
 /// Enum represents different content schemas, against which documents content would be
 /// validated.
 pub(crate) enum ContentSchema {
     /// Draft 7 JSON schema
-    Json(jsonschema::Validator),
+    Json(json_schema::JsonSchema),
 }
 
 /// Document's content validation rule
@@ -131,18 +133,15 @@ fn templated_json_schema_check(
         );
         return false;
     };
-    let Ok(schema_validator) = jsonschema::options()
-        .with_draft(jsonschema::Draft::Draft7)
-        .build(&template_json_schema)
-    else {
+    let Ok(schema) = json_schema::JsonSchema::try_from(&template_json_schema) else {
         doc.report().functional_validation(
             "Template document content must be Draft 7 JSON schema",
             "Invalid referenced template document content",
         );
         return false;
     };
 
-    content_schema_check(doc, &ContentSchema::Json(schema_validator))
+    content_schema_check(doc, &ContentSchema::Json(schema))
 }
 
 /// Validating the document's content against the provided schema
@@ -427,17 +426,12 @@ mod tests {
     #[tokio::test]
     async fn content_rule_static_test() {
         let provider = TestCatalystSignedDocumentProvider::default();
-
-        let json_schema = ContentSchema::Json(
-            jsonschema::options()
-                .with_draft(jsonschema::Draft::Draft7)
-                .build(&serde_json::json!({}))
-                .unwrap(),
-        );
+        let schema = json_schema::JsonSchema::try_from(&serde_json::json!({})).unwrap();
+        let content_schema = ContentSchema::Json(schema);
         let json_content = serde_json::to_vec(&serde_json::json!({})).unwrap();
 
         // all correct
-        let rule = ContentRule::Static(json_schema);
+        let rule = ContentRule::Static(content_schema);
         let doc = Builder::new().with_content(json_content.clone()).build();
         assert!(rule.check(&doc, &provider).await.unwrap());