fix(rust): decimal validation now accepts strings per spec

- Add validate_decimal() that accepts strings (spec) and numbers (convenience)
- Fix tagged choice validation for wrapper objects like {"creditCard": {...}}
- Add InstanceDecimalExpected error code
- Replace broken test_decimal_valid with comprehensive decimal tests
- Add test_sample_instances_are_valid for primer-and-samples coverage

Fixes decimal types which per spec 'are represented as strings to preserve
precision'. Now consistent with TypeScript, Go, and Python SDKs.

All 246 tests pass including 34 primer-and-samples instance tests.

Author: Clemens Vasters

rust/src/error_codes.rs

@@ -215,6 +215,7 @@ pub enum InstanceErrorCode {
     InstanceNumberNotMultiple,
     InstanceIntegerExpected,
     InstanceIntegerOutOfRange,
+    InstanceDecimalExpected,
 
     // Boolean/Null errors
     InstanceBooleanExpected,
@@ -326,6 +327,7 @@ impl InstanceErrorCode {
             Self::InstanceNumberNotMultiple => "INSTANCE_NUMBER_NOT_MULTIPLE",
             Self::InstanceIntegerExpected => "INSTANCE_INTEGER_EXPECTED",
             Self::InstanceIntegerOutOfRange => "INSTANCE_INTEGER_OUT_OF_RANGE",
+            Self::InstanceDecimalExpected => "INSTANCE_DECIMAL_EXPECTED",
             Self::InstanceBooleanExpected => "INSTANCE_BOOLEAN_EXPECTED",
             Self::InstanceNullExpected => "INSTANCE_NULL_EXPECTED",
             Self::InstanceObjectExpected => "INSTANCE_OBJECT_EXPECTED",

rust/src/instance_validator.rs

@@ -301,9 +301,10 @@ impl InstanceValidator {
             "uint32" => self.validate_uint32(instance, schema_obj, result, path, locator),
             "uint64" => self.validate_uint64(instance, schema_obj, result, path, locator),
             "uint128" => self.validate_uint128(instance, schema_obj, result, path, locator),
-            "float" | "float8" | "double" | "decimal" => {
+            "float" | "float8" | "double" => {
                 self.validate_number(instance, schema_obj, result, path, locator)
             }
+            "decimal" => self.validate_decimal(instance, schema_obj, result, path, locator),
             "date" => self.validate_date(instance, result, path, locator),
             "time" => self.validate_time(instance, result, path, locator),
             "datetime" => self.validate_datetime(instance, result, path, locator),
@@ -514,6 +515,128 @@ impl InstanceValidator {
         }
     }
 
+    /// Validates a decimal value.
+    /// Per the JSON Structure spec, decimal values are represented as strings
+    /// to preserve arbitrary precision. Numbers are also accepted for convenience.
+    fn validate_decimal(
+        &self,
+        instance: &Value,
+        schema_obj: &serde_json::Map<String, Value>,
+        result: &mut ValidationResult,
+        path: &str,
+        locator: &JsonSourceLocator,
+    ) {
+        let value: f64 = match instance {
+            Value::String(s) => {
+                // Decimal values should be strings per spec
+                match s.parse::<f64>() {
+                    Ok(v) => v,
+                    Err(_) => {
+                        result.add_error(ValidationError::instance_error(
+                            InstanceErrorCode::InstanceDecimalExpected,
+                            format!("Invalid decimal format: {}", s),
+                            path,
+                            locator.get_location(path),
+                        ));
+                        return;
+                    }
+                }
+            }
+            Value::Number(n) => {
+                // Also accept numbers for convenience (though strings preferred)
+                n.as_f64().unwrap_or(0.0)
+            }
+            _ => {
+                result.add_error(ValidationError::instance_error(
+                    InstanceErrorCode::InstanceDecimalExpected,
+                    "Expected decimal (as string or number)",
+                    path,
+                    locator.get_location(path),
+                ));
+                return;
+            }
+        };
+
+        // Apply numeric constraints if extended validation is enabled
+        if self.options.extended {
+            // minimum
+            if let Some(min_val) = schema_obj.get("minimum") {
+                let min = match min_val {
+                    Value::Number(n) => n.as_f64(),
+                    Value::String(s) => s.parse::<f64>().ok(),
+                    _ => None,
+                };
+                if let Some(min) = min {
+                    if value < min {
+                        result.add_error(ValidationError::instance_error(
+                            InstanceErrorCode::InstanceNumberTooSmall,
+                            format!("Value {} is less than minimum {}", value, min),
+                            path,
+                            locator.get_location(path),
+                        ));
+                    }
+                }
+            }
+
+            // maximum
+            if let Some(max_val) = schema_obj.get("maximum") {
+                let max = match max_val {
+                    Value::Number(n) => n.as_f64(),
+                    Value::String(s) => s.parse::<f64>().ok(),
+                    _ => None,
+                };
+                if let Some(max) = max {
+                    if value > max {
+                        result.add_error(ValidationError::instance_error(
+                            InstanceErrorCode::InstanceNumberTooLarge,
+                            format!("Value {} is greater than maximum {}", value, max),
+                            path,
+                            locator.get_location(path),
+                        ));
+                    }
+                }
+            }
+
+            // exclusiveMinimum
+            if let Some(min_val) = schema_obj.get("exclusiveMinimum") {
+                let min = match min_val {
+                    Value::Number(n) => n.as_f64(),
+                    Value::String(s) => s.parse::<f64>().ok(),
+                    _ => None,
+                };
+                if let Some(min) = min {
+                    if value <= min {
+                        result.add_error(ValidationError::instance_error(
+                            InstanceErrorCode::InstanceNumberTooSmall,
+                            format!("Value {} is not greater than exclusive minimum {}", value, min),
+                            path,
+                            locator.get_location(path),
+                        ));
+                    }
+                }
+            }
+
+            // exclusiveMaximum
+            if let Some(max_val) = schema_obj.get("exclusiveMaximum") {
+                let max = match max_val {
+                    Value::Number(n) => n.as_f64(),
+                    Value::String(s) => s.parse::<f64>().ok(),
+                    _ => None,
+                };
+                if let Some(max) = max {
+                    if value >= max {
+                        result.add_error(ValidationError::instance_error(
+                            InstanceErrorCode::InstanceNumberTooLarge,
+                            format!("Value {} is not less than exclusive maximum {}", value, max),
+                            path,
+                            locator.get_location(path),
+                        ));
+                    }
+                }
+            }
+        }
+    }
+
     fn validate_int32(
         &self,
         instance: &Value,
@@ -1674,7 +1797,33 @@ impl InstanceValidator {
                 ));
             }
         } else {
-            // Untagged choice - try to match one
+            // Tagged choice (no selector) - instance should be an object with one property
+            // matching a choice name, e.g., {"creditCard": {...}}
+            let obj = match instance {
+                Value::Object(o) => o,
+                _ => {
+                    result.add_error(ValidationError::instance_error(
+                        InstanceErrorCode::InstanceChoiceNoMatch,
+                        "Value does not match any choice option",
+                        path,
+                        locator.get_location(path),
+                    ));
+                    return;
+                }
+            };
+
+            // Check if it's a tagged union (object with exactly one property matching a choice)
+            if obj.len() == 1 {
+                let (tag, value) = obj.iter().next().unwrap();
+                if let Some(choice_schema) = choices.get(tag) {
+                    // Validate the wrapped value against the choice schema
+                    let value_path = format!("{}/{}", path, tag);
+                    self.validate_instance(value, choice_schema, root_schema, result, &value_path, locator, depth + 1);
+                    return;
+                }
+            }
+
+            // If not a tagged union, try untagged choice - try to match one
             let mut match_count = 0;
 
             for (_choice_name, choice_schema) in choices {

rust/tests/instance_validator_tests.rs

@@ -226,17 +226,72 @@ fn test_double_valid() {
 }
 
 #[test]
-fn test_decimal_valid() {
+fn test_decimal_string_valid() {
+    // Per the JSON Structure spec, decimal types are represented as strings
+    // to preserve arbitrary precision
+    let schema = json!({
+        "type": "decimal"
+    });
+    let validator = InstanceValidator::new();
+    
+    // String format is the spec-compliant way
+    let result = validator.validate(r#""123.456""#, &schema);
+    assert!(result.is_valid(), "String '123.456' should be valid decimal");
+    
+    let result = validator.validate(r#""0.0875""#, &schema);
+    assert!(result.is_valid(), "String '0.0875' should be valid decimal");
+    
+    let result = validator.validate(r#""-999.99""#, &schema);
+    assert!(result.is_valid(), "Negative string decimal should be valid");
+    
+    let result = validator.validate(r#""12345678901234567890.123456789""#, &schema);
+    assert!(result.is_valid(), "High-precision string decimal should be valid");
+}
+
+#[test]
+fn test_decimal_number_also_valid() {
+    // Numbers are also accepted for convenience, though strings are preferred
     let schema = json!({
         "type": "decimal"
     });
     let validator = InstanceValidator::new();
 
     let result = validator.validate("123.456", &schema);
-    assert!(result.is_valid(), "123.456 should be valid decimal");
+    assert!(result.is_valid(), "JSON number 123.456 should be valid decimal");
+    
+    let result = validator.validate("-99.5", &schema);
+    assert!(result.is_valid(), "Negative JSON number should be valid decimal");
+}
+
+#[test]
+fn test_decimal_invalid_string_format() {
+    let schema = json!({
+        "type": "decimal"
+    });
+    let validator = InstanceValidator::new();
+    
+    let result = validator.validate(r#""not-a-number""#, &schema);
+    assert!(!result.is_valid(), "Non-numeric string should fail decimal validation");
+    
+    let result = validator.validate(r#""12.34.56""#, &schema);
+    assert!(!result.is_valid(), "Malformed decimal string should fail");
+}
+
+#[test]
+fn test_decimal_wrong_type() {
+    let schema = json!({
+        "type": "decimal"
+    });
+    let validator = InstanceValidator::new();
+    
+    let result = validator.validate("true", &schema);
+    assert!(!result.is_valid(), "Boolean should fail decimal validation");
+    
+    let result = validator.validate("null", &schema);
+    assert!(!result.is_valid(), "Null should fail decimal validation");
 
-    // Note: String decimals may or may not be supported depending on implementation
-    // The primary format is JSON number
+    let result = validator.validate(r#"["123.45"]"#, &schema);
+    assert!(!result.is_valid(), "Array should fail decimal validation");
 }
 
 // =============================================================================

rust/tests/test_assets_tests.rs

@@ -347,6 +347,8 @@ fn prepare_instance_for_validation(instance: &Value, schema: &Value) -> Value {
         obj.remove("_description");
         obj.remove("_expectedError");
         obj.remove("_expectedValid");
+        // $schema is a meta-annotation, not instance data
+        obj.remove("$schema");
     }
 
     // Check if schema expects a primitive/array type and instance has { value: ... } wrapper
@@ -556,3 +558,99 @@ fn test_sample_schemas_are_valid() {
     // Note: Some tests fail due to union types (type as array) not being supported yet
     // assert_eq!(failed, 0, "Some sample schemas failed validation");
 }
+
+/// Test that sample instance files from primer-and-samples validate against their schemas
+#[test]
+fn test_sample_instances_are_valid() {
+    let samples_dir = match find_samples_dir() {
+        Some(dir) => dir,
+        None => {
+            eprintln!("samples directory not found, skipping test");
+            return;
+        }
+    };
+
+    let mut passed = 0;
+    let mut failed = 0;
+    let mut skipped = 0;
+
+    // Get all sample directories
+    let sample_dirs = get_subdirs(&samples_dir);
+
+    for sample_dir in &sample_dirs {
+        let schema_file = sample_dir.join("schema.struct.json");
+        if !schema_file.exists() {
+            continue;
+        }
+
+        let category_name = get_test_name(sample_dir);
+        
+        // Load the schema
+        let schema = match load_json(&schema_file) {
+            Some(s) => s,
+            None => {
+                eprintln!("  ✗ {} - failed to load schema", category_name);
+                failed += 1;
+                continue;
+            }
+        };
+
+        // Find example*.json files in this directory
+        let instance_files: Vec<PathBuf> = fs::read_dir(sample_dir)
+            .map(|entries| {
+                entries
+                    .filter_map(|e| e.ok())
+                    .map(|e| e.path())
+                    .filter(|p| {
+                        let name = p.file_name().unwrap_or_default().to_string_lossy();
+                        name.starts_with("example") && name.ends_with(".json")
+                    })
+                    .collect()
+            })
+            .unwrap_or_default();
+
+        if instance_files.is_empty() {
+            skipped += 1;
+            continue;
+        }
+
+        let mut validator = InstanceValidator::new();
+        validator.set_extended(true);
+
+        for instance_file in &instance_files {
+            let instance_name = instance_file.file_name()
+                .map(|n| n.to_string_lossy().to_string())
+                .unwrap_or_else(|| "unknown".to_string());
+
+            let instance_data = match load_json(instance_file) {
+                Some(d) => d,
+                None => {
+                    eprintln!("  ✗ {}/{} - failed to load instance", category_name, instance_name);
+                    failed += 1;
+                    continue;
+                }
+            };
+
+            // Prepare instance (remove $schema and other meta fields)
+            let instance = prepare_instance_for_validation(&instance_data, &schema);
+            let instance_json = serde_json::to_string(&instance).unwrap();
+
+            let result = validator.validate(&instance_json, &schema);
+
+            if result.is_valid() {
+                passed += 1;
+            } else {
+                eprintln!(
+                    "  ✗ {}/{} - should be valid: {:?}",
+                    category_name,
+                    instance_name,
+                    result.errors().next()
+                );
+                failed += 1;
+            }
+        }
+    }
+
+    println!("Sample Instance Tests: {} passed, {} failed, {} skipped", passed, failed, skipped);
+    assert_eq!(failed, 0, "Some sample instances failed validation");
+}