PHP code example of iviphp / validation

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

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

    

iviphp / validation example snippets

declare(strict_types=1);

use Ivi\Validation\Rules\Email;
use Ivi\Validation\Rules\Required;
use Ivi\Validation\Rules\StringType;
use Ivi\Validation\Validator;

$result = Validator::make(
    data: [
        'name' => 'Gaspard',
        'email' => '[email protected]',
    ],
    rules: [
        'name' => [
            new Required(),
            new StringType(),
        ],
        'email' => [
            new Required(),
            new Email(),
        ],
    ]
);

if ($result->passes()) {
    $validated = $result->validated();
}

if ($result->fails()) {
    $errors = $result->errors();
}

declare(strict_types=1);

use Ivi\Validation\Rules\Required;
use Ivi\Validation\Rules\StringType;
use Ivi\Validation\Validator;

$validator = new Validator([
    'title' => [
        new Required(),
        new StringType(),
    ],
]);

$result = $validator->validate([
    'title' => 'My article',
]);

$result = Validator::make(
    data: [
        'user' => [
            'name' => 'Gaspard',
            'email' => '[email protected]',
        ],
    ],
    rules: [
        'user.name' => [
            new Required(),
            new StringType(),
        ],
        'user.email' => [
            new Required(),
            new Email(),
        ],
    ]
);

$validated = $result->validated();

[
    'user' => [
        'name' => 'Gaspard',
        'email' => '[email protected]',
    ],
]

use Ivi\Validation\Rules\Required;

$result = Validator::make(
    data: [
        'name' => '',
    ],
    rules: [
        'name' => [
            new Required(),
        ],
    ]
);

use Ivi\Validation\Rules\Email;
use Ivi\Validation\Rules\Nullable;

$result = Validator::make(
    data: [
        'secondary_email' => null,
    ],
    rules: [
        'secondary_email' => [
            new Nullable(),
            new Email(),
        ],
    ]
);

[
    'secondary_email' => '',
]

'email' => [
    new Required(),
    new Nullable(),
    new Email(),
]

use Ivi\Validation\Rules\StringType;

$result = Validator::make(
    data: [
        'name' => 'IviPHP',
    ],
    rules: [
        'name' => [
            new StringType(),
        ],
    ]
);

use Ivi\Validation\Rules\IntegerType;

$result = Validator::make(
    data: [
        'quantity' => 12,
    ],
    rules: [
        'quantity' => [
            new IntegerType(),
        ],
    ]
);

[
    'quantity' => '12',
]

use Ivi\Validation\Rules\Numeric;

$result = Validator::make(
    data: [
        'price' => '24.50',
    ],
    rules: [
        'price' => [
            new Numeric(),
        ],
    ]
);

use Ivi\Validation\Rules\Email;

$result = Validator::make(
    data: [
        'email' => '[email protected]',
    ],
    rules: [
        'email' => [
            new Email(),
        ],
    ]
);

use Ivi\Validation\Rules\MinLength;

$result = Validator::make(
    data: [
        'password' => 'secret123',
    ],
    rules: [
        'password' => [
            new MinLength(8),
        ],
    ]
);

'tags' => [
    new MinLength(2),
]

use Ivi\Validation\Rules\MaxLength;

$result = Validator::make(
    data: [
        'username' => 'gaspard',
    ],
    rules: [
        'username' => [
            new MaxLength(30),
        ],
    ]
);

'categories' => [
    new MaxLength(5),
]

use Ivi\Validation\Rules\In;

$result = Validator::make(
    data: [
        'status' => 'published',
    ],
    rules: [
        'status' => [
            new In([
                'draft',
                'published',
                'archived',
            ]),
        ],
    ]
);

new In([1, 2, 3])

new In(
    allowedValues: [1, 2, 3],
    strict: false
)

new Required(
    'Please provide :field.'
)

new MinLength(
    minimum: 8,
    customMessage: ':field must contain at least :min characters.'
)

new MaxLength(
    maximum: 100,
    customMessage: ':field cannot exceed :max characters.'
)

new In(
    allowedValues: [
        'draft',
        'published',
    ],
    customMessage: ':field must be one of: :values.'
)

$result->passes();
$result->fails();

$errors = $result->errors();

[
    'email' => [
        'The email field must be a valid email address.',
    ],
]

if ($result->has('email')) {
    // The email field has errors.
}

$messages = $result->errorsFor('email');

$message = $result->first('email');

$message = $result->first();

$messages = $result->messages();

$count = $result->errorCount();

$result = Validator::make(
    data: [
        'name' => 'Gaspard',
        'email' => '[email protected]',
        'admin' => true,
    ],
    rules: [
        'name' => [
            new Required(),
        ],
        'email' => [
            new Required(),
            new Email(),
        ],
    ]
);

$validated = $result->validated();

[
    'name' => 'Gaspard',
    'email' => '[email protected]',
]

$name = $result->value('name');

$email = $result->value('user.email');

$result->hasValue('user.email');

$result = Validator::make(
    data: [],
    rules: [
        'nickname' => [
            new StringType(),
        ],
    ]
);

$result = Validator::make(
    data: [
        'email' => '',
    ],
    rules: [
        'email' => [
            new Required(),
            new Email(),
            new MinLength(10),
        ],
    ]
);

$result = Validator::make(
    data: [
        'email' => '',
    ],
    rules: [
        'email' => [
            new Required(),
            new Email(),
            new MinLength(10),
        ],
    ],
    stopOnFirstFailure: true
);

$validator = new Validator($rules);

$fastValidator = $validator
    ->withStopOnFirstFailure();

$completeValidator = $fastValidator
    ->withoutStopOnFirstFailure();

use Ivi\Validation\Exceptions\ValidationException;

$result = Validator::make(
    data: [
        'email' => 'invalid',
    ],
    rules: [
        'email' => [
            new Required(),
            new Email(),
        ],
    ]
);

if ($result->fails()) {
    throw ValidationException::fromResult($result);
}

try {
    throw ValidationException::fromResult($result);
} catch (ValidationException $exception) {
    $errors = $exception->errors();
    $first = $exception->first();
}

$exception->result();
$exception->errors();
$exception->errorsFor($field);
$exception->has($field);
$exception->first($field);
$exception->messages();
$exception->errorCount();
$exception->validated();

declare(strict_types=1);

use Ivi\Validation\RuleInterface;

final readonly class StartsWith implements RuleInterface
{
    public function __construct(
        private string $prefix
    ) {}

    public function passes(
        string $field,
        mixed $value,
        array $data
    ): bool {
        return is_string($value)
            && str_starts_with(
                $value,
                $this->prefix
            );
    }

    public function message(string $field): string
    {
        return "The {$field} field must start with {$this->prefix}.";
    }
}

$result = Validator::make(
    data: [
        'reference' => 'IVI-100',
    ],
    rules: [
        'reference' => [
            new Required(),
            new StartsWith('IVI-'),
        ],
    ]
);

final readonly class MatchesField implements RuleInterface
{
    public function __construct(
        private string $otherField
    ) {}

    public function passes(
        string $field,
        mixed $value,
        array $data
    ): bool {
        return array_key_exists(
            $this->otherField,
            $data
        ) && $value === $data[$this->otherField];
    }

    public function message(string $field): string
    {
        return "The {$field} field must match {$this->otherField}.";
    }
}

declare(strict_types=1);

use Ivi\Validation\Exceptions\ValidationException;
use Ivi\Validation\Rules\Email;
use Ivi\Validation\Rules\In;
use Ivi\Validation\Rules\IntegerType;
use Ivi\Validation\Rules\MaxLength;
use Ivi\Validation\Rules\MinLength;
use Ivi\Validation\Rules\Nullable;
use Ivi\Validation\Rules\Required;
use Ivi\Validation\Rules\StringType;
use Ivi\Validation\Validator;

$data = [
    'name' => 'Gaspard Kirira',
    'email' => '[email protected]',
    'age' => 28,
    'role' => 'admin',
    'bio' => null,
];

$result = Validator::make(
    data: $data,
    rules: [
        'name' => [
            new Required(),
            new StringType(),
            new MinLength(2),
            new MaxLength(100),
        ],
        'email' => [
            new Required(),
            new Email(),
        ],
        'age' => [
            new Required(),
            new IntegerType(),
        ],
        'role' => [
            new Required(),
            new In([
                'member',
                'admin',
            ]),
        ],
        'bio' => [
            new Nullable(),
            new StringType(),
            new MaxLength(500),
        ],
    ],
    stopOnFirstFailure: true
);

if ($result->fails()) {
    throw ValidationException::fromResult($result);
}

$validated = $result->validated();

$rule->passes($field, $value, $data);
$rule->message($field);

Validator::make(
    $data,
    $rules,
    $stopOnFirstFailure
);

$validator->validate($data);
$validator->rules();
$validator->stopsOnFirstFailure();
$validator->withStopOnFirstFailure();
$validator->withoutStopOnFirstFailure();

$result->passes();
$result->fails();

$result->has($field);
$result->errors();
$result->errorsFor($field);
$result->first($field);
$result->messages();
$result->errorCount();

$result->validated();
$result->value($key, $default);
$result->hasValue($key);

ValidationException::fromResult(
    $result,
    $message,
    $previous
);

$exception->result();
$exception->errors();
$exception->errorsFor($field);
$exception->has($field);
$exception->first($field);
$exception->messages();
$exception->errorCount();
$exception->validated();

new Required();
new Required($customMessage);

new Nullable();

new StringType();
new StringType($customMessage);

new IntegerType();
new IntegerType($customMessage);

new Numeric();
new Numeric($customMessage);

new Email();
new Email($customMessage);

new MinLength($minimum);
new MinLength($minimum, $customMessage);

new MaxLength($maximum);
new MaxLength($maximum, $customMessage);

new In($allowedValues);

new In(
    $allowedValues,
    $strict,
    $customMessage
);