PHP code example of bishalshrestha / fynix

    
        
<?php
require_once('vendor/autoload.php');

/* Start to develop here. Best regards https://php-download.com/ */

    

bishalshrestha / fynix example snippets

use Fynix\RuleSet;
use Fynix\ValidationHandler;
use Fynix\ValidationRegistry;

final class User
{
    public string $firstName = '';
    public string $email = '';
}

ValidationRegistry::register(
    User::class,
    static fn (RuleSet $rules): array => [
        $rules->string('firstName')->min(2)->max(50),
        $rules->email('email')->max(254),
    ],
);

$user = new User();
$user->firstName = 'A';
$user->email = 'not-an-email';

$errors = ValidationHandler::validate($user);

[
    'firstName' => 'First Name is too short. This field must be at least 2 characters.',
    'email' => 'Email must be a valid email address.',
]

use Fynix\Rule;

$emailError = Rule::email('email')
    ->max(254)
    ->validate('not-an-email');

$passwordErrors = Rule::password('password')
    ->length(12, 128)
    ->validateAll('short');

$rules = [
    Rule::on(User::class)->string('firstName')->min(2)->max(50),
    Rule::on(User::class)->email('email')->max(254),
];

$errors = ValidationHandler::validate($user, rules: $rules);

$error = Rule::for($user)
    ->string('firstName')
    ->min(2)
    ->max(50)
    ->validate();

ValidationRegistry::register(
    Registration::class,
    static fn (RuleSet $rules): array => [
        $rules->string('companyName')
            ->optional()
            ->

final class Address
{
    public string $city = '';
}

final class Customer
{
    public ?Address $address = null;
}

ValidationRegistry::register(
    Address::class,
    static fn (RuleSet $rules): array => [
        $rules->string('city')->min(2)->max(80),
    ],
);

ValidationRegistry::register(
    Customer::class,
    static fn (RuleSet $rules): array => [
        $rules->object('address', Address::class)->optional(),
    ],
);

$errors = ValidationHandler::validate(new Customer());

ValidationRegistry::register(
    Order::class,
    static fn (RuleSet $rules): array => [
        $rules->objectArray('items', LineItem::class)->min(1)->max(100),
    ],
);

$errors = ValidationHandler::validate($user);
$flatErrors = ValidationHandler::validateAndFlatten($user);

// firstName => "First Name is 

$errors = ValidationHandler::validate(
    $user,
    flattenErrorToString: false,
);

$payload = [];
foreach ($errors as $field => $issues) {
    foreach ((array) $issues as $issue) {
        $payload[] = $issue->toArray();
    }
}

$results = ValidationHandler::validateMany($user, $profile);

$namedResults = ValidationHandler::validateManyAssoc([
    'user' => $user,
    'profile' => $profile,
]);

use Fynix\Rule;
use Fynix\Rules\AllOf;
use Fynix\Rules\AnyOf;
use Fynix\Rules\Not;

$name = new AllOf([
    Rule::string('name')->min(2),
    Rule::string('name')->max(80),
]);

$contact = new AnyOf([
    Rule::email('contact'),
    Rule::phoneNumber('contact'),
]);

$status = new Not(
    Rule::string('status')->in(['blocked']),
    'This status is not allowed.',
);

use Fynix\ValidationError;
use Fynix\Validators\ValidatorBase;

final class EvenNumberValidator extends ValidatorBase
{
    protected function validateValue(mixed $fieldValue): ?ValidationError
    {
        if (!is_int($fieldValue) || $fieldValue % 2 !== 0) {
            return new ValidationError($this, "$this->name must be even.", 'number.even');
        }

        return null;
    }
}

ValidationHandler::addListener($listener);
$errors = ValidationHandler::validate($user);
ValidationHandler::clearListeners();