Compares two profiles and returns the differences in their configurations.

This function is useful for understanding how profiles differ and for documentation or debugging purposes.

Examples

ExJsonschema.Profile.compare(:strict, :performance)
#=> %{
#     validate_formats: {true, false},
#     output_format: {:verbose, :basic},
#     stop_on_first_error: {false, true},
#     collect_annotations: {true, false},
#     regex_engine: {:fancy_regex, :regex}
#   }

Returns the options for the specified profile name.

This function provides a convenient way to access profiles by name, useful for configuration-driven applications.

Examples

opts = ExJsonschema.Profile.get(:strict)
# Same as: ExJsonschema.Profile.strict()

opts = ExJsonschema.Profile.get(:performance, output_format: :detailed)
# Same as: ExJsonschema.Profile.performance(output_format: :detailed)

Returns the lenient validation profile.

The lenient profile balances validation quality with user-friendliness, making it ideal for user-facing forms, content management, and scenarios where some flexibility improves user experience.

Configuration Highlights

• User-friendly errors: Detailed format with helpful messages
• Flexible drafts: Automatic draft detection for mixed schemas
• Balanced performance: Good speed without sacrificing essential features

Use Cases

• Web form validation
• User-generated content validation
• Content management systems
• Mobile app data validation
• Prototyping and development

Options

Override options to fine-tune the lenient behavior:

# Lenient but with format validation for critical fields
ExJsonschema.Profile.lenient(validate_formats: true)

# Lenient but with different output format
ExJsonschema.Profile.lenient(output_format: :verbose)

Examples

schema = ~s({"type": "object", "properties": {"age": {"type": "number", "custom-format": "range"}}})
{:ok, validator} = ExJsonschema.compile(schema, ExJsonschema.Profile.lenient())

# Will ignore unknown custom format
ExJsonschema.validate(validator, ~s({"age": 25}))
#=> :ok

Lists all available profile names.

Examples

ExJsonschema.Profile.list()
#=> [:strict, :lenient, :performance]

Returns the performance-optimized validation profile.

The performance profile prioritizes speed and throughput, making it ideal for high-volume batch processing, real-time validation, and scenarios where validation happens in tight loops.

Configuration Highlights

• Maximum speed: Minimal validation features
• Lightweight errors: Basic error format, essential information only
• Performance shortcuts: Simple regex engine
• Memory efficient: Optimized for high-volume processing

Use Cases

• High-frequency API endpoints
• Stream processing and ETL pipelines
• Batch data validation jobs
• Real-time event validation
• Performance-critical microservices

Options

You can selectively enable features when performance allows:

# Performance profile but collect errors for debugging
ExJsonschema.Profile.performance(output_format: :detailed)

# Performance profile but validate critical formats
ExJsonschema.Profile.performance(validate_formats: true)

Examples

schema = ~s({"type": "object", "required": ["id"]})
{:ok, validator} = ExJsonschema.compile(schema, ExJsonschema.Profile.performance())

# Fast validation with minimal error details
ExJsonschema.valid?(validator, ~s({"id": "123"}))
#=> true

ExJsonschema.validate(validator, ~s({}))
#=> {:error, :validation_failed}  # Basic error format

Returns the strict validation profile.

The strict profile maximizes validation rigor and security, making it ideal for API validation, data integrity checks, and scenarios where compliance is critical.

Configuration Highlights

• Maximum validation: All formats validated
• Comprehensive errors: Verbose output with full context and suggestions
• No performance shortcuts: Quality over speed

Use Cases

• REST API request/response validation
• Configuration file validation
• Data import/export validation
• Compliance and audit scenarios
• Development and testing environments

Options

You can override any option while maintaining the strict profile's character:

# Strict but with basic error format for performance
ExJsonschema.Profile.strict(output_format: :basic)

# Strict but with different regex engine
ExJsonschema.Profile.strict(regex_engine: :regex)

Examples

schema = ~s({"type": "object", "properties": {"email": {"type": "string", "format": "email"}}})
{:ok, validator} = ExJsonschema.compile(schema, ExJsonschema.Profile.strict())

# Will catch format violations
ExJsonschema.validate(validator, ~s({"email": "invalid-email"}))
#=> {:error, [%ValidationError{message: "invalid-email is not a valid email format", ...}]}