README

DataValidation is a lightweight, high-performance PHP validation library engineered for enterprise-grade applications. Outperforming alternatives with up to 61.8x faster validation for invalid data, it excels in speed and memory efficiency while seamlessly handling complex nested data with wildcards. With no dependencies, comprehensive test coverage, and a developer-friendly API, DataValidation empowers teams to build scalable, secure systems with confidence.

Why DataValidation?

DataValidation sets a new standard for PHP validation with its performance and flexibility:

• Unmatched Speed: Validates 5000 items in 1.499 seconds for valid data, up to 5.2x faster than Laravel’s Illuminate\Validation (7.724 seconds). For invalid data, it’s up to 61.8x faster (1.502 seconds vs. 92.814 seconds).
• Memory Efficiency: Maintains a low memory footprint, with peak usage of 10.000 MB for 5000 items, compared to 25.500 MB for alternatives.
• Wildcard Support: Effortlessly handles nested arrays with wildcards (e.g., users.*.email), ideal for complex API payloads.
• Extensibility: Supports custom rules via closures or classes, enabling tailored validation logic.

Installation

Install via Composer:

composer require yorcreative/data-validation

Requirements:

• PHP 8.3 or 8.4

Basic Usage

Validate data with a clean, intuitive API adhering to PSR-12 standards:

use YorCreative\DataValidation\Validator;

$data = [
    'name' => 'John Doe',
    'email' => 'john@example.com'
];
$rules = [
    'name' => 'required|string',
    'email' => 'required|email'
];

$validator = Validator::make($data, $rules);
if ($validator->validate()) {
    echo "Validation passed!";
} else {
    print_r($validator->errors());
}

Supported Rules

DataValidation provides a comprehensive set of validation rules to meet diverse business needs:

Note: Unknown rules or invalid parameters throw an InvalidArgumentException during initialization, ensuring early detection of configuration issues.

Advanced Usage

Validating Nested Data with Wildcards

Efficiently validate complex nested data structures using wildcards, ideal for API-driven applications:

use YorCreative\DataValidation\Validator;

$data = [
    'users' => [
        ['profile' => ['email' => 'user1@example.com', 'confirm_email' => 'user1@example.com']],
        ['profile' => ['email' => 'user2@example.com', 'confirm_email' => 'user2@example.com']]
    ]
];
$rules = [
    'users.*.profile.email' => 'required|email|same:users.*.profile.confirm_email'
];

$validator = Validator::make($data, $rules);
if ($validator->validate()) {
    echo "All user emails are valid and match their confirmations!";
} else {
    print_r($validator->errors());
}

Custom Validation Rules with Closures

Enable rapid prototyping of business-specific rules using closures:

use YorCreative\DataValidation\Validator;

$validator = Validator::make(['score' => 85], [
    'score' => [
        function ($field, $value, $fail) {
            if ($value < 90) {
                $fail("The {$field} must be at least 90 to pass the elite threshold.");
            }
        }
    ]
]);

Custom Error Messages

Tailor error messages to enhance user experience and align with business requirements:

use YorCreative\DataValidation\Validator;

$messages = [
    'name.required' => 'Please provide a name.',
    'email.email' => 'Enter a valid email address.'
];
$validator = Validator::make(
    ['name' => '', 'email' => 'invalid'],
    ['name' => 'required', 'email' => 'email'],
    $messages
);
print_r($validator->errors());

Custom Attribute Names

Improve error message clarity with user-friendly attribute names:

use YorCreative\DataValidation\Validator;

$attributes = ['user.email' => 'Email Address', 'user.name' => 'Full Name'];
$validator = Validator::make(
    ['user' => ['email' => 'invalid', 'name' => '']],
    ['user.email' => 'email', 'user.name' => 'required'],
    [],
    $attributes
);
print_r($validator->errors());

Stopping on First Error

Optimize performance in latency-sensitive applications by halting validation after the first error:

use YorCreative\DataValidation\Validator;

$validator = Validator::make($data, $rules, [], [], true);
if ($validator->fails()) {
    echo "Validation stopped at first error: " . implode(', ', $validator->errors()['user.email']);
}

Extending with Custom Rules

For applications requiring bespoke validation logic, implement custom rules via ValidationRuleInterface:

namespace App\Rules;

use YorCreative\DataValidation\Rules\ValidationRuleInterface;

class PhoneNumberRule implements ValidationRuleInterface
{
    public function validate(string $field, $value, array $parameters, array $data): bool
    {
        return preg_match('/^\+?1?\d{10}$/', $value) === 1;
    }

    public function getErrorMessage(string $field, array $parameters, ?string $customMessage): string
    {
        return $customMessage ?? sprintf('The %s must be a valid US phone number.', $field);
    }

    public function validateParameters(string $field, array $parameters): void
    {
    }
}

Register the custom rule directory for seamless integration:

use YorCreative\DataValidation\Rules\RuleRegistry;

RuleRegistry::registerCustomRuleDirectory(__DIR__ . '/Rules');

Use it in validation workflows:

use YorCreative\DataValidation\Validator;

$validator = Validator::make(
    ['phone' => '1234567890'],
    ['phone' => 'required|phone_number']
);

Alternatively, register a closure-based rule:

use YorCreative\DataValidation\Rules\RuleRegistry;

RuleRegistry::registerClosureRule('phone', function ($value) {
    return preg_match('/^\+?1?\d{10}$/', $value) === 1;
}, 'The :attribute must be a valid US phone number.');

Performance Benchmarks

DataValidation is optimized for speed and efficiency, particularly for large datasets and wildcard validations. Benchmarks were conducted on an Apple M1 chip with 10 cores, running PHP 8.4, ensuring optimal conditions for performance evaluation. The following results compare DataValidation (DV) with Laravel's Illuminate\Validation (IL) across different dataset sizes.

Benchmark Results for Valid Data

Benchmark Results for Invalid Data

Scalability for Large Datasets

For extremely large datasets, such as 100,000 items, YorCreative\DataValidation completes validation in approximately 9.2 minutes (553.462 seconds for valid data) with a peak memory usage of 262.012 MB, demonstrating its ability to handle massive amounts of data efficiently. This scalability is crucial for enterprise-grade batch processing, ensuring reliability and performance in production environments.

Key Definitions

• DV (DataValidation): The YorCreative\DataValidation library, optimized for lightweight, high-performance validation tailored to enterprise needs.
• IL (Illuminate\Validation): Laravel’s validation component, a robust but resource-intensive alternative commonly used in PHP ecosystems.
• Time (s): Time in seconds to validate the dataset.
• Mem (MB): Peak memory usage in megabytes during validation.
• Items: Number of records in the dataset (e.g., 1000 users, each with profile and settings data).

Context and Insights

• Performance Advantage: DataValidation delivers up to 61.8x faster processing for invalid data (1.502 s vs. 92.814 s for 5000 items) and 5.2x for valid data (1.499 s vs. 7.724 s), reducing latency in critical API endpoints.
• Memory Efficiency: Maintains a low memory footprint (10.000 MB peak for 5000 items), compared to Illuminate\Validation’s 25.500 MB for valid data and 110.000 MB for invalid data, enabling cost-effective scaling.
• Wildcard Optimization: Leverages stack-based traversal and caching to handle wildcard rules (e.g., users.*.email), addressing performance bottlenecks in Laravel.

Running Benchmarks

To validate performance in your environment:

composer benchmark-all

This command executes benchmarks for both DataValidation and Illuminate\Validation, providing detailed metrics. Ensure sufficient memory (4GB recommended) for accurate results.

Contributing

Contributions are welcome! Fork the repository, create a feature branch, and submit a pull request ensuring tests pass.

DataValidation includes extensive unit and feature tests for reliability.

composer test

Report issues or suggest features on the GitHub repository.

License

DataValidation is licensed under the MIT License. See the LICENSE file for details.