feat(cli): Schema-only validation now also validates all referenced schemas

Signed-off-by: Dmitry Dygalo <[email protected]>

Author: Stranger6667

CHANGELOG.md

@@ -5,6 +5,7 @@
 ### Added
 
 - `evaluate()` top-level function for convenient access to structured validation output.
+- **CLI**: Schema-only validation now also validates all referenced schemas. [#804](https://github.com/Stranger6667/jsonschema/issues/804)
 
 ### Changed
 

crates/jsonschema-cli/src/main.rs

@@ -187,14 +187,27 @@ fn output_schema_validation(
     output: Output,
     errors_only: bool,
 ) -> Result<bool, Box<dyn std::error::Error>> {
+    // First validate against meta-schema
     let meta_validator = jsonschema::meta::validator_for(schema_json)?;
     let evaluation = meta_validator.evaluate(schema_json);
     let flag_output = evaluation.flag();
 
+    // If meta-schema validation passed, also try to build the validator
+    // to check that all referenced schemas are valid
+    if flag_output.valid {
+        let base_uri = path_to_uri(schema_path);
+        let base_uri = referencing::uri::from_str(&base_uri)?;
+        // Just try to build - if it fails, the error propagates naturally
+        jsonschema::options()
+            .with_base_uri(base_uri)
+            .build(schema_json)?;
+    }
+
     // Skip valid schemas if errors_only is enabled
     if !(errors_only && flag_output.valid) {
         let schema_display = schema_path.to_string_lossy().to_string();
         let output_format = output.as_str();
+
         let payload = match output {
             Output::Text => unreachable!("text mode should not call this function"),
             Output::Flag => serde_json::to_value(flag_output)?,
@@ -222,8 +235,20 @@ fn validate_schema_meta(
 
     if matches!(output, Output::Text) {
         // Text output mode
-        match jsonschema::meta::validate(&schema_json) {
-            Ok(()) => {
+        // First validate the schema structure against its meta-schema
+        if let Err(error) = jsonschema::meta::validate(&schema_json) {
+            println!("Schema is invalid. Error: {error}");
+            return Ok(false);
+        }
+
+        // Then try to build a validator to check that all referenced schemas are also valid
+        let base_uri = path_to_uri(schema_path);
+        let base_uri = referencing::uri::from_str(&base_uri)?;
+        match jsonschema::options()
+            .with_base_uri(base_uri)
+            .build(&schema_json)
+        {
+            Ok(_) => {
                 if !errors_only {
                     println!("Schema is valid");
                 }

crates/jsonschema-cli/tests/cli.rs

@@ -884,3 +884,125 @@ fn test_validate_schema_with_json_parse_error() {
     let stdout = String::from_utf8_lossy(&output.stdout);
     assert!(stdout.contains("Error:"));
 }
+
+#[test]
+fn test_validate_schema_with_invalid_referenced_schema() {
+    // This test verifies that when a schema references another schema via $ref,
+    // and that referenced schema is invalid, the validation should fail.
+    let dir = tempdir().unwrap();
+
+    // Main schema is structurally valid
+    let main_schema = create_temp_file(
+        &dir,
+        "main.json",
+        r#"{
+            "$schema": "http://json-schema.org/draft-07/schema#",
+            "type": "object",
+            "properties": {
+                "user": { "$ref": "user.json" }
+            }
+        }"#,
+    );
+
+    // Referenced schema is structurally INVALID (bad type value)
+    let _ref_schema = create_temp_file(
+        &dir,
+        "user.json",
+        r#"{
+            "type": "invalid_type_here",
+            "properties": {
+                "name": { "type": "string" }
+            }
+        }"#,
+    );
+
+    let mut cmd = cli();
+    cmd.arg(&main_schema);
+    let output = cmd.output().unwrap();
+
+    // Schema validation should fail because the referenced schema is invalid
+    assert!(!output.status.success());
+    let stdout = String::from_utf8_lossy(&output.stdout);
+    assert!(stdout.contains("Schema is invalid"));
+}
+
+#[test]
+fn test_validate_schema_with_valid_referenced_schema() {
+    // This test verifies that when all referenced schemas are valid, validation succeeds.
+    let dir = tempdir().unwrap();
+
+    let main_schema = create_temp_file(
+        &dir,
+        "main.json",
+        r#"{
+            "$schema": "http://json-schema.org/draft-07/schema#",
+            "type": "object",
+            "properties": {
+                "user": { "$ref": "user.json" }
+            }
+        }"#,
+    );
+
+    // Referenced schema is structurally VALID
+    let _ref_schema = create_temp_file(
+        &dir,
+        "user.json",
+        r#"{
+            "type": "object",
+            "properties": {
+                "name": { "type": "string" }
+            }
+        }"#,
+    );
+
+    let mut cmd = cli();
+    cmd.arg(&main_schema);
+    let output = cmd.output().unwrap();
+
+    // Schema validation should succeed because all schemas are valid
+    assert!(output.status.success());
+    let stdout = String::from_utf8_lossy(&output.stdout);
+    assert!(stdout.contains("Schema is valid"));
+}
+
+#[test]
+fn test_validate_schema_with_invalid_ref_structured_output() {
+    // This test verifies structured output when root schema is valid but referenced schema is invalid.
+    // This exercises the code path where flag_output.valid is true, but build fails.
+    let dir = tempdir().unwrap();
+
+    let main_schema = create_temp_file(
+        &dir,
+        "main.json",
+        r#"{
+            "$schema": "http://json-schema.org/draft-07/schema#",
+            "type": "object",
+            "properties": {
+                "user": { "$ref": "user.json" }
+            }
+        }"#,
+    );
+
+    // Referenced schema is structurally INVALID
+    let _ref_schema = create_temp_file(
+        &dir,
+        "user.json",
+        r#"{
+            "type": "invalid_type_here",
+            "properties": {
+                "name": { "type": "string" }
+            }
+        }"#,
+    );
+
+    let mut cmd = cli();
+    cmd.arg(&main_schema).arg("--output").arg("flag");
+    let output = cmd.output().unwrap();
+
+    // Should fail
+    assert!(!output.status.success());
+
+    // Should get an error message (not structured output since build fails before we can output)
+    let stdout = String::from_utf8_lossy(&output.stdout);
+    assert!(stdout.contains("Error:"));
+}