feat!(core): better validation messages

Author: gadomski

crates/cli/src/input.rs

@@ -1,6 +1,9 @@
 use crate::{options::Options, Error, Result};
 use stac::{Format, Value};
-use std::io::Read;
+use std::{
+    fs::File,
+    io::{BufReader, Read},
+};
 use url::Url;
 
 /// The input to a CLI run.
@@ -76,8 +79,16 @@ impl Input {
                     }
                 }
             } else {
-                let value: Value = format.from_path(href)?;
-                serde_json::to_value(value).map_err(Error::from)
+                match format {
+                    Format::Json(..) => {
+                        let file = BufReader::new(File::open(href)?);
+                        serde_json::from_reader(file).map_err(Error::from)
+                    }
+                    _ => {
+                        let value: Value = format.from_path(href)?;
+                        serde_json::to_value(value).map_err(Error::from)
+                    }
+                }
             }
         } else {
             let mut buf = Vec::new();

crates/cli/src/subcommand/validate.rs

@@ -17,27 +17,8 @@ impl Run for Args {
         let value = input.get_json().await?;
         let result = value.validate().await;
         if let Err(stac::Error::Validation(ref errors)) = result {
-            let id = value
-                .get("id")
-                .and_then(|v| v.as_str())
-                .map(|v| format!("={}", v))
-                .unwrap_or_default();
-            let message_base = match value
-                .get("type")
-                .and_then(|v| v.as_str())
-                .unwrap_or_default()
-            {
-                "Feature" => format!("[item={}] ", id),
-                "Catalog" => format!("[catalog={}] ", id),
-                "Collection" => format!("[collection={}] ", id),
-                "FeatureCollection" => "[item-collection] ".to_string(),
-                _ => String::new(),
-            };
             for error in errors {
-                eprintln!(
-                    "{}{} (instance path: '{}', schema path: '{}')",
-                    message_base, error, error.instance_path, error.schema_path
-                );
+                eprintln!("{error}");
             }
         }
         result.and(Ok(None)).map_err(Error::from)

crates/core/src/error.rs

@@ -1,6 +1,4 @@
 use crate::Version;
-#[cfg(feature = "validate")]
-use jsonschema::ValidationError;
 use thiserror::Error;
 
 /// Error enum for crate-specific errors.
@@ -135,33 +133,84 @@ pub enum Error {
     Url(#[from] url::ParseError),
 
     /// A list of validation errors.
-    ///
-    /// Since we usually don't have the original [serde_json::Value] (because we
-    /// create them from the STAC objects), we need these errors to be `'static`
-    /// lifetime.
-    #[error("validation errors")]
+    #[error("{} validation error(s)", .0.len())]
+    #[cfg(feature = "validate")]
+    Validation(Vec<Validation>),
+
+    /// [jsonschema::ValidationError]
     #[cfg(feature = "validate")]
-    Validation(Vec<ValidationError<'static>>),
+    #[error(transparent)]
+    JsonschemaValidation(#[from] jsonschema::ValidationError<'static>),
+}
+
+/// A validation error
+#[cfg(feature = "validate")]
+#[derive(Debug)]
+pub struct Validation {
+    /// The ID of the STAC object that failed to validate.
+    id: Option<String>,
+
+    /// The type of the STAC object that failed to validate.
+    r#type: Option<crate::Type>,
+
+    /// The validation error.
+    error: jsonschema::ValidationError<'static>,
+}
+
+#[cfg(feature = "validate")]
+impl Validation {
+    pub(crate) fn new(
+        error: jsonschema::ValidationError<'_>,
+        value: Option<&serde_json::Value>,
+    ) -> Validation {
+        use std::borrow::Cow;
+
+        // Cribbed from https://docs.rs/jsonschema/latest/src/jsonschema/error.rs.html#21-30
+        let error = jsonschema::ValidationError {
+            instance_path: error.instance_path.clone(),
+            instance: Cow::Owned(error.instance.into_owned()),
+            kind: error.kind,
+            schema_path: error.schema_path,
+        };
+        let mut id = None;
+        let mut r#type = None;
+        if let Some(value) = value.and_then(|v| v.as_object()) {
+            id = value.get("id").and_then(|v| v.as_str()).map(String::from);
+            r#type = value
+                .get("type")
+                .and_then(|v| v.as_str())
+                .and_then(|s| s.parse::<crate::Type>().ok());
+        }
+        Validation { id, r#type, error }
+    }
 }
 
 #[cfg(feature = "validate")]
 impl Error {
-    pub(crate) fn from_validation_errors<'a, I>(errors: I) -> Error
+    pub(crate) fn from_validation_errors<'a, I>(
+        errors: I,
+        value: Option<&serde_json::Value>,
+    ) -> Error
     where
-        I: Iterator<Item = ValidationError<'a>>,
+        I: Iterator<Item = jsonschema::ValidationError<'a>>,
     {
-        use std::borrow::Cow;
+        Error::Validation(errors.map(|error| Validation::new(error, value)).collect())
+    }
+}
 
-        let mut error_vec = Vec::new();
-        for error in errors {
-            // Cribbed from https://docs.rs/jsonschema/latest/src/jsonschema/error.rs.html#21-30
-            error_vec.push(ValidationError {
-                instance_path: error.instance_path.clone(),
-                instance: Cow::Owned(error.instance.into_owned()),
-                kind: error.kind,
-                schema_path: error.schema_path,
-            })
+#[cfg(feature = "validate")]
+impl std::fmt::Display for Validation {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        if let Some(r#type) = self.r#type {
+            if let Some(id) = self.id.as_ref() {
+                write!(f, "{}[id={id}]: {}", r#type, self.error)
+            } else {
+                write!(f, "{}: {}", r#type, self.error)
+            }
+        } else if let Some(id) = self.id.as_ref() {
+            write!(f, "[id={id}]: {}", self.error)
+        } else {
+            write!(f, "{}", self.error)
         }
-        Error::Validation(error_vec)
     }
 }

crates/core/src/lib.rs

@@ -178,6 +178,8 @@ mod validate;
 mod value;
 mod version;
 
+use std::fmt::Display;
+
 #[cfg(feature = "validate-blocking")]
 pub use validate::ValidateBlocking;
 #[cfg(feature = "validate")]
@@ -297,6 +299,12 @@ where
     }
 }
 
+impl Display for Type {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "{}", self.as_str())
+    }
+}
+
 /// Utility function to deserialize the type field on an object.
 ///
 /// Use this, via a wrapper function, for `#[serde(deserialize_with)]`.

crates/core/src/validate/validator.rs

@@ -154,7 +154,7 @@ impl Validator {
             let value = Arc::new(Value::Object(object));
             let mut result = schema
                 .validate(&value)
-                .map_err(Error::from_validation_errors);
+                .map_err(|e| Error::from_validation_errors(e, Some(&value)));
             if result.is_ok() {
                 result = validator.validate_extensions(value.clone()).await
             }
@@ -201,7 +201,7 @@ impl Validator {
                     let extension_schema = validator.schema(extension).await?;
                     extension_schema
                         .validate(&value)
-                        .map_err(Error::from_validation_errors)
+                        .map_err(|errors| Error::from_validation_errors(errors, Some(&value)))
                 });
             }
         }
@@ -232,10 +232,7 @@ impl Validator {
         let schema = {
             let cache = self.cache.read().unwrap();
             let value = cache.get(&uri).expect("we just resolved it");
-            let schema = self
-                .validation_options
-                .build(value)
-                .map_err(|err| Error::from_validation_errors([err].into_iter()))?;
+            let schema = self.validation_options.build(value)?;
             Arc::new(schema)
         };
         {