slices_lexicon/

lib.rs

//! # AT Protocol Lexicon Validator
//!
//! This crate provides validation for AT Protocol Lexicon schema documents and data records.
//! Lexicon is a schema definition language used to describe atproto records, HTTP endpoints (XRPC),
//! and event stream messages.
//!
//! ## Features
//!
//! - **Schema validation**: Validate lexicon documents against the lexicon specification
//! - **Data validation**: Validate data records against their lexicon schemas
//! - **Cross-reference checking**: Ensure all references between lexicons can be resolved
//! - **Format validation**: Support for AT Protocol string formats (DIDs, handles, NSIDs, etc.)
//! - **WebAssembly support**: Optional WASM bindings for browser/JS usage
//!
//! ## Basic Usage
//!
//! ```rust
//! use slices_lexicon::{validate, ValidationError};
//! use serde_json::json;
//!
//! let lexicons = vec![
//!     json!({
//!         "lexicon": 1,
//!         "id": "com.example.post",
//!         "defs": {
//!             "main": {
//!                 "type": "record",
//!                 "key": "tid",
//!                 "record": {
//!                     "type": "object",
//!                     "required": ["text"],
//!                     "properties": {
//!                         "text": { "type": "string", "maxLength": 300 }
//!                     }
//!                 }
//!             }
//!         }
//!     })
//! ];
//!
//! match validate(lexicons) {
//!     Ok(_) => println!("All lexicons are valid!"),
//!     Err(errors) => {
//!         for (lexicon_id, error_list) in errors {
//!             println!("Errors in {}: {:?}", lexicon_id, error_list);
//!         }
//!     }
//! }
//! ```
//!
//! ## Advanced Usage with Validation Context
//!
//! ```rust
//! use slices_lexicon::validation::{ValidationContext, primary::RecordValidator, Validator};
//! use serde_json::json;
//!
//! # fn main() -> Result<(), Box<dyn std::error::Error>> {
//! let lexicons = vec![
//!     json!({
//!         "lexicon": 1,
//!         "id": "com.example.post",
//!         "defs": {
//!             "main": {
//!                 "type": "record",
//!                 "key": "tid",
//!                 "record": {
//!                     "type": "object",
//!                     "required": ["text"],
//!                     "properties": {
//!                         "text": { "type": "string" }
//!                     }
//!                 }
//!             }
//!         }
//!     })
//! ];
//!
//! let ctx = ValidationContext::builder()
//!     .with_lexicons(lexicons)?
//!     .build()?;
//!
//! let validator = RecordValidator;
//! let record_def = json!({
//!     "type": "record",
//!     "key": "tid",
//!     "record": {
//!         "type": "object",
//!         "required": ["text"],
//!         "properties": {
//!             "text": { "type": "string" }
//!         }
//!     }
//! });
//! validator.validate(&record_def, &ctx)?;
//! # Ok(())
//! # }
//! ```

pub mod errors;
pub mod types;
pub mod validation;

use std::collections::HashMap;
use serde_json::Value;

// Import all validators for data validation
use crate::validation::{
    primitive::{
        string::StringValidator, integer::IntegerValidator, boolean::BooleanValidator,
        bytes::BytesValidator, blob::BlobValidator, cid_link::CidLinkValidator,
        null::NullValidator,
    },
    field::{
        object::ObjectValidator, array::ArrayValidator, union::UnionValidator,
        reference::RefValidator,
    },
    meta::{
        token::TokenValidator, unknown::UnknownValidator,
    },
    primary::{
        record::RecordValidator, query::QueryValidator, procedure::ProcedureValidator,
        subscription::SubscriptionValidator,
    },
};

pub use errors::ValidationError;
pub use types::{LexiconDoc, StringFormat};
pub use validation::{ValidationContext, ValidationContextBuilder, Validator};

/// Validates a set of lexicon documents
///
/// This is the primary entry point for validating lexicon schemas. It performs
/// comprehensive validation including:
/// - Structural validation of each lexicon document
/// - Type checking of all definitions
/// - Cross-reference resolution checking
/// - Format validation
///
/// # Arguments
///
/// * `lexicons` - Vector of JSON lexicon documents to validate
///
/// # Returns
///
/// * `Ok(())` if all lexicons are valid
/// * `Err(HashMap<String, Vec<String>>)` mapping lexicon IDs to error messages
///
/// # Examples
///
/// ```rust
/// use slices_lexicon::validate;
/// use serde_json::json;
///
/// let lexicons = vec![
///     json!({
///         "lexicon": 1,
///         "id": "com.example.post",
///         "defs": {
///             "main": {
///                 "type": "record",
///                 "key": "tid",
///                 "record": {
///                     "type": "object",
///                     "required": ["text"],
///                     "properties": {
///                         "text": { "type": "string" }
///                     }
///                 }
///             }
///         }
///     })
/// ];
///
/// match validate(lexicons) {
///     Ok(_) => println!("Valid!"),
///     Err(errors) => {
///         for (id, errs) in errors {
///             println!("{}: {:?}", id, errs);
///         }
///     }
/// }
/// ```
///
/// # Errors
///
/// This function returns an error map where:
/// - Keys are lexicon IDs (or "parse_error" for JSON parsing issues)
/// - Values are vectors of human-readable error messages
///
/// Common error types include:
/// - Missing required fields (`lexicon`, `id`, `defs`)
/// - Invalid lexicon version (only version 1 is supported)
/// - Invalid NSID format
/// - Type mismatches in definitions
/// - Missing references
/// - Constraint violations
pub fn validate(lexicons: Vec<Value>) -> Result<(), HashMap<String, Vec<String>>> {
    use validation::{ValidationContext, primary, field, primitive, meta};

    let mut all_errors = HashMap::new();

    // Create validation context
    let ctx = match ValidationContext::builder().with_lexicons(lexicons).and_then(|b| b.build()) {
        Ok(context) => context,
        Err(_) => {
            let mut errors = HashMap::new();
            errors.insert("context".to_string(), vec!["Failed to build validation context".to_string()]);
            return Err(errors);
        }
    };

    // Validate each lexicon
    for (lexicon_id, lexicon_doc) in &ctx.lexicons {
        let mut lexicon_errors = Vec::new();

        // Validate each definition in the lexicon
        if let Some(defs) = lexicon_doc.defs.as_object() {
            for (def_name, def_value) in defs {
                let def_context = ctx.with_current_lexicon(lexicon_id)
                    .with_path(&format!("{}#{}", lexicon_id, def_name));

                if let Some(type_str) = def_value.get("type").and_then(|t| t.as_str()) {
                    let validation_result = match type_str {
                        // Primary types
                        "record" => primary::record::RecordValidator.validate(def_value, &def_context),
                        "query" => primary::query::QueryValidator.validate(def_value, &def_context),
                        "procedure" => primary::procedure::ProcedureValidator.validate(def_value, &def_context),
                        "subscription" => primary::subscription::SubscriptionValidator.validate(def_value, &def_context),

                        // Field types
                        "object" => field::object::ObjectValidator.validate(def_value, &def_context),
                        "array" => field::array::ArrayValidator.validate(def_value, &def_context),
                        "union" => field::union::UnionValidator.validate(def_value, &def_context),
                        "ref" => field::reference::RefValidator.validate(def_value, &def_context),
                        // TODO: Implement params validator
                        // "params" => field::params::ParamsValidator.validate(def_value, &def_context),

                        // Primitive types
                        "string" => primitive::string::StringValidator.validate(def_value, &def_context),
                        "integer" => primitive::integer::IntegerValidator.validate(def_value, &def_context),
                        "boolean" => primitive::boolean::BooleanValidator.validate(def_value, &def_context),
                        "bytes" => primitive::bytes::BytesValidator.validate(def_value, &def_context),
                        "blob" => primitive::blob::BlobValidator.validate(def_value, &def_context),
                        "cid-link" => primitive::cid_link::CidLinkValidator.validate(def_value, &def_context),
                        "null" => primitive::null::NullValidator.validate(def_value, &def_context),

                        // Meta types
                        "token" => meta::token::TokenValidator.validate(def_value, &def_context),
                        "unknown" => meta::unknown::UnknownValidator.validate(def_value, &def_context),

                        _ => Err(ValidationError::InvalidSchema(format!("Unknown type: {}", type_str))),
                    };

                    if let Err(error) = validation_result {
                        lexicon_errors.push(error.to_string());
                    }
                } else {
                    lexicon_errors.push(format!("Definition '{}' missing 'type' field", def_name));
                }
            }
        }

        if !lexicon_errors.is_empty() {
            all_errors.insert(lexicon_id.clone(), lexicon_errors);
        }
    }

    if all_errors.is_empty() {
        Ok(())
    } else {
        Err(all_errors)
    }
}

/// Validates a single data record against its lexicon schema
///
/// This function validates runtime data against a previously loaded lexicon.
/// It's useful for validating records before storing them or API responses.
///
/// # Arguments
///
/// * `lexicons` - Vector of lexicon documents (must include the collection's lexicon)
/// * `collection` - The collection name (NSID) that defines the record schema
/// * `record` - The data record to validate
///
/// # Returns
///
/// * `Ok(())` if the record is valid
/// * `Err(ValidationError)` with detailed error information
///
/// # Examples
///
/// ```rust
/// use slices_lexicon::validate_record;
/// use serde_json::json;
///
/// let lexicons = vec![/* ... */];
/// let record = json!({
///     "$type": "com.example.post",
///     "text": "Hello, world!",
///     "createdAt": "2024-01-01T12:00:00Z"
/// });
///
/// match validate_record(lexicons, "com.example.post", record) {
///     Ok(_) => println!("Record is valid!"),
///     Err(e) => println!("Validation error: {}", e),
/// }
/// ```
///
/// # Errors
///
/// Returns a [`ValidationError`] if:
/// - The lexicon for the collection is not found
/// - The record doesn't match the schema (missing fields, wrong types, etc.)
/// - Constraints are violated (string length, integer range, etc.)
/// - Format validation fails (invalid DIDs, handles, etc.)
pub fn validate_record(
    lexicons: Vec<Value>,
    collection: &str,
    record: Value
) -> Result<(), ValidationError> {
    // Build validation context with lexicons
    let ctx = ValidationContext::builder()
        .with_lexicons(lexicons)
        .map_err(|_| ValidationError::InvalidSchema("Failed to build validation context".to_string()))?
        .build()
        .map_err(|_| ValidationError::InvalidSchema("Failed to build validation context".to_string()))?;

    // Find the lexicon for this collection
    let lexicon = ctx.get_lexicon(collection)
        .ok_or_else(|| ValidationError::LexiconNotFound(collection.to_string()))?;

    // Get the main definition (records are always in 'main')
    let main_def = lexicon.defs.as_object()
        .and_then(|defs| defs.get("main"))
        .ok_or_else(|| ValidationError::InvalidSchema(format!(
            "Lexicon '{}' missing main definition", collection
        )))?;

    // Verify it's a record type
    let type_str = main_def.get("type")
        .and_then(|t| t.as_str())
        .ok_or_else(|| ValidationError::InvalidSchema(format!(
            "Lexicon '{}' main definition missing type", collection
        )))?;

    if type_str != "record" {
        return Err(ValidationError::InvalidSchema(format!(
            "Lexicon '{}' main definition is not a record type", collection
        )));
    }

    // Get the record schema
    let record_schema = main_def.get("record")
        .ok_or_else(|| ValidationError::InvalidSchema(format!(
            "Record definition '{}' missing 'record' field", collection
        )))?;

    // Validate the record data against the schema
    validate_data_against_schema(&record, record_schema, &ctx.with_current_lexicon(collection).with_path(collection))
}

/// Internal function to validate data against a schema
fn validate_data_against_schema(data: &Value, schema: &Value, ctx: &ValidationContext) -> Result<(), ValidationError> {
    use crate::validation::Validator;

    if let Some(type_str) = schema.get("type").and_then(|t| t.as_str()) {
        match type_str {
            // Primitive types
            "string" => StringValidator.validate_data(data, schema, ctx),
            "integer" => IntegerValidator.validate_data(data, schema, ctx),
            "boolean" => BooleanValidator.validate_data(data, schema, ctx),
            "bytes" => BytesValidator.validate_data(data, schema, ctx),
            "blob" => BlobValidator.validate_data(data, schema, ctx),
            "cid-link" => CidLinkValidator.validate_data(data, schema, ctx),
            "null" => NullValidator.validate_data(data, schema, ctx),

            // Field types
            "object" => ObjectValidator.validate_data(data, schema, ctx),
            "array" => ArrayValidator.validate_data(data, schema, ctx),
            "union" => UnionValidator.validate_data(data, schema, ctx),
            "ref" => RefValidator.validate_data(data, schema, ctx),

            // Meta types
            "token" => TokenValidator.validate_data(data, schema, ctx),
            "unknown" => UnknownValidator.validate_data(data, schema, ctx),

            // Primary types
            "record" => RecordValidator.validate_data(data, schema, ctx),
            "query" => QueryValidator.validate_data(data, schema, ctx),
            "procedure" => ProcedureValidator.validate_data(data, schema, ctx),
            "subscription" => SubscriptionValidator.validate_data(data, schema, ctx),

            // Unknown type
            _ => Err(ValidationError::InvalidSchema(format!(
                "Unknown schema type '{}' at '{}'", type_str, ctx.path()
            ))),
        }
    } else {
        Err(ValidationError::InvalidSchema(format!(
            "Schema missing type field at '{}'", ctx.path()
        )))
    }
}

/// Utility function to check if a string is a valid NSID (Namespaced Identifier)
///
/// NSIDs are used to identify lexicons, collections, and other AT Protocol concepts.
/// They follow a reverse-domain-name format like `com.example.collection`.
///
/// # Arguments
///
/// * `nsid` - The string to validate
///
/// # Returns
///
/// * `true` if the string is a valid NSID
/// * `false` otherwise
///
/// # Examples
///
/// ```rust
/// use slices_lexicon::is_valid_nsid;
///
/// assert!(is_valid_nsid("com.example.post"));
/// assert!(is_valid_nsid("app.bsky.feed.post"));
/// assert!(!is_valid_nsid("invalid"));
/// assert!(!is_valid_nsid("com.example"));  // needs at least 3 segments
/// ```
pub fn is_valid_nsid(nsid: &str) -> bool {
    use regex::Regex;
    // NSID must have at least 3 segments (domain.subdomain.collection)
    let nsid_regex = Regex::new(
        r"^[a-zA-Z]([a-zA-Z0-9-]*[a-zA-Z0-9])?(\.[a-zA-Z]([a-zA-Z0-9-]*[a-zA-Z0-9])?){2,}$",
    )
    .unwrap();
    nsid_regex.is_match(nsid)
}

// WASM-specific code - only compiled when the wasm feature is enabled
#[cfg(feature = "wasm")]
mod wasm_bindings {
    use super::*;
    use wasm_bindgen::prelude::*;
    use crate::validation::ValidationContext;

    // When the `console_error_panic_hook` feature is enabled, we can call the
    // `set_panic_hook` function at least once during initialization, and then
    // we will get better error messages if our code ever panics.
    //
    // For more details see
    // https://github.com/rustwasm/console_error_panic_hook#readme
    #[cfg(feature = "console_error_panic_hook")]
    #[wasm_bindgen(start)]
    pub fn main() {
        console_error_panic_hook::set_once();
    }

    // WASM-exposed validator wrapper using the new validation system
    #[wasm_bindgen]
    pub struct WasmLexiconValidator {
        context: ValidationContext,
    }

    #[wasm_bindgen]
    impl WasmLexiconValidator {
        /// Create a new validator with the given lexicon documents
        /// Takes a JSON string containing an array of lexicon documents
        #[wasm_bindgen(constructor)]
        pub fn new(lexicons_json: &str) -> Result<WasmLexiconValidator, JsValue> {
            let lexicons: Vec<Value> = serde_json::from_str(lexicons_json)
                .map_err(|e| JsValue::from_str(&format!("Failed to parse lexicons JSON: {}", e)))?;

            let context = ValidationContext::builder()
                .with_lexicons(lexicons)
                .map_err(|e| JsValue::from_str(&format!("Failed to build validation context: {}", e)))?
                .build()
                .map_err(|e| JsValue::from_str(&format!("Failed to build validation context: {}", e)))?;

            Ok(WasmLexiconValidator { context })
        }

        /// Validate a record against its collection's lexicon
        /// Takes collection name and record as JSON strings
        #[wasm_bindgen]
        pub fn validate_record(&self, collection: &str, record_json: &str) -> Result<(), JsValue> {
            let record: Value = serde_json::from_str(record_json)
                .map_err(|e| JsValue::from_str(&format!("Failed to parse record JSON: {}", e)))?;

            validate_data_against_schema(&record, &self.get_record_schema(collection)?, &self.context.with_path(collection))
                .map_err(|e| JsValue::from_str(&e.to_string()))
        }

        /// Validate lexicon documents and return detailed validation results
        /// Returns a JSON string containing validation results with enhanced error context
        #[wasm_bindgen]
        pub fn validate_lexicons(&self) -> String {
            let mut results = HashMap::new();

            for (lexicon_id, lexicon_doc) in &self.context.lexicons {
                let mut lexicon_errors = Vec::new();

                if let Some(defs) = lexicon_doc.defs.as_object() {
                    for (def_name, def_value) in defs {
                        let def_context = self.context.with_path(&format!("{}#{}", lexicon_id, def_name));

                        if let Some(type_str) = def_value.get("type").and_then(|t| t.as_str()) {
                            let validation_result = validate_definition_by_type(def_value, type_str, &def_context);

                            if let Err(error) = validation_result {
                                lexicon_errors.push(format!("{}#{}: {}", lexicon_id, def_name, error));
                            }
                        } else {
                            lexicon_errors.push(format!("{}#{}: Missing 'type' field", lexicon_id, def_name));
                        }
                    }
                }

                if !lexicon_errors.is_empty() {
                    results.insert(lexicon_id.clone(), lexicon_errors);
                }
            }

            serde_json::to_string(&results).unwrap_or_else(|_| "{}".to_string())
        }

        /// Check if all references in the lexicon set can be resolved
        /// Returns a JSON string with any unresolved references
        #[wasm_bindgen]
        pub fn check_references(&self) -> String {
            let mut unresolved_refs = Vec::new();

            for (lexicon_id, lexicon_doc) in &self.context.lexicons {
                if let Some(defs) = lexicon_doc.defs.as_object() {
                    for (def_name, def_value) in defs {
                        collect_unresolved_references(def_value, &format!("{}#{}", lexicon_id, def_name), &self.context, &mut unresolved_refs);
                    }
                }
            }

            serde_json::to_string(&unresolved_refs).unwrap_or_else(|_| "[]".to_string())
        }

        /// Get detailed error context for validation failures
        /// Returns enhanced error information with path context
        #[wasm_bindgen]
        pub fn get_error_context(&self, path: &str) -> String {
            let ctx = self.context.with_path(path);
            serde_json::json!({
                "path": ctx.path(),
                "current_lexicon": ctx.current_lexicon_id,
                "has_circular_reference": !ctx.reference_stack.is_empty(),
                "reference_stack": ctx.reference_stack
            }).to_string()
        }

        // Helper method to get record schema
        fn get_record_schema(&self, collection: &str) -> Result<Value, JsValue> {
            let lexicon = self.context.get_lexicon(collection)
                .ok_or_else(|| JsValue::from_str(&format!("Lexicon not found: {}", collection)))?;

            let main_def = lexicon.defs.as_object()
                .and_then(|defs| defs.get("main"))
                .ok_or_else(|| JsValue::from_str(&format!("Missing main definition in lexicon: {}", collection)))?;

            let record_schema = main_def.get("record")
                .ok_or_else(|| JsValue::from_str(&format!("Missing record schema in lexicon: {}", collection)))?;

            Ok(record_schema.clone())
        }
    }

    // Helper function to validate definitions by type
    fn validate_definition_by_type(def_value: &Value, type_str: &str, ctx: &ValidationContext) -> Result<(), ValidationError> {
        use crate::validation::Validator;

        match type_str {
            // Primary types
            "record" => RecordValidator.validate(def_value, ctx),
            "query" => QueryValidator.validate(def_value, ctx),
            "procedure" => ProcedureValidator.validate(def_value, ctx),
            "subscription" => SubscriptionValidator.validate(def_value, ctx),

            // Field types
            "object" => ObjectValidator.validate(def_value, ctx),
            "array" => ArrayValidator.validate(def_value, ctx),
            "union" => UnionValidator.validate(def_value, ctx),
            "ref" => RefValidator.validate(def_value, ctx),

            // Primitive types
            "string" => StringValidator.validate(def_value, ctx),
            "integer" => IntegerValidator.validate(def_value, ctx),
            "boolean" => BooleanValidator.validate(def_value, ctx),
            "bytes" => BytesValidator.validate(def_value, ctx),
            "blob" => BlobValidator.validate(def_value, ctx),
            "cid-link" => CidLinkValidator.validate(def_value, ctx),
            "null" => NullValidator.validate(def_value, ctx),

            // Meta types
            "token" => TokenValidator.validate(def_value, ctx),
            "unknown" => UnknownValidator.validate(def_value, ctx),

            _ => Err(ValidationError::InvalidSchema(format!("Unknown type: {}", type_str))),
        }
    }

    // Helper function to collect unresolved references
    fn collect_unresolved_references(value: &Value, path: &str, ctx: &ValidationContext, unresolved: &mut Vec<String>) {
        match value {
            Value::Object(obj) => {
                if let Some(ref_str) = obj.get("$ref").and_then(|r| r.as_str()) {
                    if ctx.resolve_reference(ref_str).is_err() {
                        unresolved.push(format!("{}: {}", path, ref_str));
                    }
                }

                for (key, val) in obj {
                    collect_unresolved_references(val, &format!("{}.{}", path, key), ctx, unresolved);
                }
            },
            Value::Array(arr) => {
                for (i, val) in arr.iter().enumerate() {
                    collect_unresolved_references(val, &format!("{}[{}]", path, i), ctx, unresolved);
                }
            },
            _ => {}
        }
    }

    /// Validate lexicons and return errors without creating a validator instance
    /// Returns a JSON string containing a map of lexicon ID to error arrays
    #[wasm_bindgen]
    pub fn validate_lexicons_and_get_errors(lexicons_json: &str) -> String {
        match validate_lexicons_from_json(lexicons_json) {
            Ok(_) => "{}".to_string(), // No errors
            Err(errors) => serde_json::to_string(&errors).unwrap_or_else(|_| "{}".to_string())
        }
    }

    // Helper function to validate lexicons from JSON string
    fn validate_lexicons_from_json(lexicons_json: &str) -> Result<(), HashMap<String, Vec<String>>> {
        let lexicons: Vec<Value> = serde_json::from_str(lexicons_json)
            .map_err(|e| {
                let mut error_map = HashMap::new();
                error_map.insert("parse_error".to_string(), vec![format!("Failed to parse lexicons JSON: {}", e)]);
                error_map
            })?;

        validate(lexicons)
    }

    // Export individual validation functions for more granular use
    #[wasm_bindgen]
    pub fn validate_string_format(value: &str, format: &str) -> Result<(), JsValue> {
        use crate::validation::primitive::string::StringValidator;
        use crate::StringFormat;

        let format_enum = format.parse::<StringFormat>()
            .map_err(|_| JsValue::from_str(&format!("Unknown format: {}", format)))?;

        let validator = StringValidator;

        // Call the individual format validation methods directly
        let is_valid = match format_enum {
            StringFormat::DateTime => validator.is_valid_rfc3339_datetime(value),
            StringFormat::Uri => validator.is_valid_uri(value),
            StringFormat::AtUri => validator.is_valid_at_uri(value),
            StringFormat::Did => validator.is_valid_did(value),
            StringFormat::Handle => validator.is_valid_handle(value),
            StringFormat::AtIdentifier => {
                validator.is_valid_did(value) || validator.is_valid_handle(value)
            },
            StringFormat::Nsid => crate::is_valid_nsid(value),
            StringFormat::Cid => validator.is_valid_cid(value),
            StringFormat::Language => validator.is_valid_language_tag(value),
            StringFormat::Tid => validator.is_valid_tid(value),
            StringFormat::RecordKey => validator.is_valid_record_key(value),
        };

        if is_valid {
            Ok(())
        } else {
            Err(JsValue::from_str(&format!("Invalid {} format: {}", format, value)))
        }
    }

    // Utility function to check if a string is a valid lexicon ID (uses shared implementation)
    #[wasm_bindgen]
    pub fn is_valid_nsid(nsid: &str) -> bool {
        crate::is_valid_nsid(nsid)
    }
}

// Re-export WASM bindings when the feature is enabled
#[cfg(feature = "wasm")]
pub use wasm_bindings::*;

#[cfg(test)]
mod test_multiple_errors_example {
    use super::*;
    use serde_json::json;

    #[test]
    fn test_multiple_error_collection_comprehensive() {
        let lexicons = vec![
            // First lexicon with multiple errors
            json!({
                "lexicon": 1,
                "id": "com.example.post",
                "defs": {
                    "main": {
                        "type": "record",
                        "key": "tid",
                        // Missing required "record" field - ERROR 1
                    },
                    "metadata": {
                        "type": "badtype"  // Invalid type - ERROR 2
                    },
                    "config": {
                        // Missing "type" field entirely - ERROR 3
                        "description": "Some config"
                    }
                }
            }),

            // Second lexicon with multiple errors
            json!({
                "lexicon": 1,
                "id": "com.example.profile",
                "defs": {
                    "main": {
                        "type": "record",
                        "key": "tid",
                        "record": {
                            "type": "object",
                            "properties": {
                                "avatar": {
                                    "type": "ref",
                                    "$ref": "com.missing.lexicon#image"  // Invalid reference - ERROR 4
                                }
                            }
                        }
                    },
                    "settings": {
                        "type": "object",
                        "properties": {
                            "theme": {
                                "type": "invalidtype"  // Invalid type - ERROR 5
                            }
                        }
                    }
                }
            }),

            // Third lexicon that's completely valid
            json!({
                "lexicon": 1,
                "id": "com.example.valid",
                "defs": {
                    "main": {
                        "type": "record",
                        "key": "tid",
                        "record": {
                            "type": "object",
                            "properties": {
                                "text": {"type": "string"}
                            }
                        }
                    }
                }
            })
        ];

        match validate(lexicons) {
            Ok(_) => panic!("Expected validation errors but validation passed"),
            Err(errors) => {
                // Test that we have errors for the expected lexicons
                assert!(errors.contains_key("com.example.post"), "Should have errors for com.example.post");
                assert!(errors.contains_key("com.example.profile"), "Should have errors for com.example.profile");
                assert!(!errors.contains_key("com.example.valid"), "Should NOT have errors for valid lexicon");

                // Test that we collected multiple errors per lexicon (not just the first one)
                assert_eq!(errors["com.example.post"].len(), 3, "com.example.post should have exactly 3 errors");
                assert_eq!(errors["com.example.profile"].len(), 2, "com.example.profile should have exactly 2 errors");

                // Test specific error messages exist (verifying all errors were collected)
                let post_errors = &errors["com.example.post"];
                assert!(post_errors.iter().any(|e| e.contains("missing 'type' field")),
                    "Should contain missing type field error");
                assert!(post_errors.iter().any(|e| e.contains("missing required 'record' field")),
                    "Should contain missing record field error");
                assert!(post_errors.iter().any(|e| e.contains("Unknown type: badtype")),
                    "Should contain unknown type error");

                let profile_errors = &errors["com.example.profile"];
                assert!(profile_errors.iter().any(|e| e.contains("Unknown schema type 'ref'")),
                    "Should contain unknown ref type error");
                assert!(profile_errors.iter().any(|e| e.contains("invalidtype")),
                    "Should contain invalidtype error");

                // Verify total error count
                let total_errors: usize = errors.values().map(|v| v.len()).sum();
                assert_eq!(total_errors, 5, "Should have collected all 5 errors total");
                assert_eq!(errors.len(), 2, "Should have errors for exactly 2 lexicons");
            }
        }
    }

    #[test]
    fn test_broken_reference_validation() {
        let broken_lexicon = json!({
            "lexicon": 1,
            "id": "test.broken.ref",
            "defs": {
                "main": {
                    "type": "object",
                    "properties": {
                        "items": {
                            "type": "array",
                            "items": {
                                "type": "ref",
                                "ref": "#nonExistentDef"
                            }
                        }
                    }
                },
                "existingDef": {
                    "type": "string"
                }
            }
        });

        let result = validate(vec![broken_lexicon]);

        // Should fail because #nonExistentDef doesn't exist
        assert!(result.is_err(), "Validation should fail for broken reference");

        if let Err(errors) = result {
            assert!(errors.contains_key("test.broken.ref"), "Should have errors for the test lexicon");
            let error_messages = errors.get("test.broken.ref").unwrap();
            assert!(!error_messages.is_empty(), "Should have at least one error");

            // Check that at least one error mentions the non-existent reference
            let has_ref_error = error_messages.iter().any(|msg|
                msg.contains("non-existent") || msg.contains("nonExistentDef")
            );
            assert!(has_ref_error, "Should have error about non-existent reference. Got: {:?}", error_messages);
        }
    }
}