Struct ApplicationValidator 

pub struct ApplicationValidator { /* private fields */ }

High-level builder pattern validator for application startup validation.

This is a high-level interface for validating permissions from multiple sources during application initialization. It provides an ergonomic API for collecting permissions incrementally before validation.

Use Cases

• Application startup: Validate permissions loaded from config, database, etc.
• Simple validation workflows: Need basic validation with automatic logging
• Builder pattern preference: Want to incrementally add permissions from different sources
• One-time validation: Don’t need post-validation analysis

Compared to PermissionCollisionChecker

• State: Stateless builder - consumed during validation
• Usage: Builder pattern with incremental permission addition
• Methods: Focus on building and validating, no post-validation introspection
• Lifecycle: Single-use - transforms into validation report
• Logging: Automatically logs validation results

For runtime validation or when you need to analyze collision details after validation, use PermissionCollisionChecker directly.

See Also

• PermissionCollisionChecker - Low-level validator with detailed analysis capabilities

Examples

Application startup validation

use axum_gate::permissions::ApplicationValidator;

// Collect permissions from multiple sources during startup
let config_permissions = load_config_permissions();
let db_permissions = load_db_permissions().await?;

let report = ApplicationValidator::new()
    .add_permissions(config_permissions)
    .add_permissions(db_permissions)
    .add_permission("system:health")  // Add individual permissions
    .validate()?;  // Automatically logs results

if report.is_valid() {
    println!("✓ All permissions validated - server can start");
} else {
    return Err(format!("Permission validation failed: {}", report.summary()).into());
}

Simple validation workflow

use axum_gate::permissions::ApplicationValidator;

// For simple cases where you just need pass/fail validation
let report = ApplicationValidator::new()
    .add_permissions(["user:read", "user:write", "admin:delete"])
    .validate()?;

// Report is automatically logged, just check if valid
if !report.is_valid() {
    panic!("Invalid permissions detected during startup");
}

Comparison with PermissionCollisionChecker

use axum_gate::permissions::{ApplicationValidator, PermissionCollisionChecker};

let permissions = vec!["user:read".to_string(), "user:write".to_string()];

// ApplicationValidator: Builder pattern, single-use, automatic logging
let report1 = ApplicationValidator::new()
    .add_permissions(permissions.clone())
    .validate()?;  // Validator is consumed here
// Can't use validator anymore, but don't need to

// PermissionCollisionChecker: Direct instantiation, reusable, manual control
let mut checker = PermissionCollisionChecker::new(permissions);
let report2 = checker.validate()?;  // Checker is still available

// Can continue using checker for analysis
if !report2.is_valid() {
    let conflicts = checker.get_conflicting_permissions("user:read");
    println!("Conflicts found: {:?}", conflicts);
}

Implementations

impl ApplicationValidator

pub fn new() -> Self

Creates a new application validator.

pub fn add_permissions<I, S>(self, permissions: I) -> Self

where I: IntoIterator<Item = S>, S: Into<String>,

Add permissions from an iterator of string-like types.

Arguments

• permissions - Iterator of items that can be converted to String

pub fn add_permission_strings(self, permissions: Vec<String>) -> Self

Add permissions from a vector of strings.

This is a convenience method for adding permissions that are already in String format.

Arguments

• permissions - Vector of permission strings

pub fn add_permission<S: Into<String>>(self, permission: S) -> Self

Add a single permission string.

Arguments

• permission - A single permission string to add

pub fn validate(self) -> Result<ValidationReport>

Validate all permissions and return detailed report.

This method performs validation and logs results automatically. It returns a ValidationReport containing all validation details, regardless of whether validation passed or failed.

Returns

• Ok(ValidationReport) - Complete validation report
• Err(axum_gate::errors::Error) - Validation process failed

pub fn permission_count(&self) -> usize

Returns the current number of permissions to be validated.

Trait Implementations

impl Default for ApplicationValidator

fn default() -> Self

Returns the “default value” for a type.