PHP Luminova: Rule-Based Input Validation

The Input Validation class in the Luminova Framework offers a powerful and flexible way to validate user-submitted data before processing or storing it in a database. It enables you to define validation rules per input field, ensuring that each field meets the expected criteria and application standards. You can also assign custom error messages for better control and user-friendly feedback.

Validation Rules

Luminova provides a wide range of built-in rules including required, min, max, email, integer, alpha, and more. Rules can be added as strings using pipe | separators, or programmatically as arrays. You can also register custom rules using callback functions to handle specific validation logic.

Defining Rules

Rules are defined per field and support parameters within parentheses. You can apply rules either individually or as part of an associative array. This makes it easy to manage validation across multiple fields in a structured and maintainable way.

Example Using Property:

$this->validate->rules = [
   'field' => 'required|max(5)',
   /* More fields*/ 
];

Example Using setRules Method:

$this->validate->setRules([
   'field' => 'required|max(5)',
   /* More fields*/ 
]);

Example of Adding Individual Field and Rules:

$this->validate->addField('field', 'required|max(5)');

Error Message Formatting

Custom error messages support dynamic placeholders such as:

• {field} Will be replaced with the name of the field being validated.
• {value} Will be replaced with the actual value that failed validation.
• {rule} Will be replaced with the name of the validation rule that was violated.

These placeholders allows you to create detailed and context-aware feedback and improves the clarity of validation responses shown to users.

Example Using Property:

$this->validate->messages = [
   'email' => [
      'required' => 'The {field} field is required.',
      'email' => 'The value "{value}" is not a valid {rule}.'
   ]
];

Example Using setMessages Method:

$this->validate->setMessages([
   'email' => [
      'required' => 'The {field} field is required.',
      'email' => 'The value "{value}" is not a valid {rule}.'
   ]
]);

Custom Validation

To define your own custom validation rule using the callback method, ensure your callback is callable and returns true for a successful validation or false for a failed validation.

Additionally, the callback function should be designed to accept two parameters:

• value (mixed) - The first parameter is the value submitted.
• field (string) - The second parameter is the input field name.

Example

Function to perform your custom validation logic.

// app/Utils/Global.php

function myCustomRule(mixed $value, string $field): bool 
{
   if ($value === 'expected_value') {
      return true;
   }
   return false;
}

Adding your function as a validation rule.

$this->validate->rules = [
   'custom_field' => 'required|callback(myCustomRule)',
];

Controller Example

Setting up validation rules and optional response messages:

// /app/Controllers/Http/SignUpController.php

namespace App\Controllers\Http;

use Luminova\Base\BaseController;

class SignUpController extends BaseController
{
   protected function onCreate(): void 
   {
      $this->validate->rules = [
         'email' => 'required|email',
         'phone' => 'required|phone(10)',
         'name' => 'required|alphabet',
      ];

      $this->validate->messages = [
         'email' => [
            'required' => 'Email is required.',
            'email' => 'Invalid email address.'
         ],
         'phone' => [
            'required' => 'Phone number is required.',
            'phone' => 'Invalid phone number.'
         ],
         'name' => [
            'required' => 'Name is required.',
            'alphabet' => 'Name contains unsupported characters.'
         ],
      ];
   }

   // Performing validation based on the defined rules:
   public function create(): int 
   {
      $body = $this->request->getBody();

      if ($this->validate->validate($body)) {
         echo 'Validation passed.';
         return STATUS_SUCCESS;
      } 

      echo 'Validation failed.';
      echo $this->validate->getErrorMessage();
      return STATUS_SUCCESS;
   }
}

Error Response

Retrieving validation error information when validation fails.

Get all validation errors:

var_dump($this->validate->getErrors());

Get the first validation error message:

echo $this->validate->getError(0);

Get the first validation error by field and error index.

echo $this->validate->getErrorMessage(0);

Get information about the first field that failed validation:

var_dump($this->validate->getErrorField(0));

Class Definition

• Class namespace: \Luminova\Security\Validation
• This class implements: \Luminova\Interface\ValidatorInterface, \Luminova\Interface\LazyInterface

Properties

rules

Define the validation rules for each form input field. The input field name should be the array key, and the validation rule(s) should be the value.

public array<string,string> $rules = [];

messages

Define custom error messages for each validation rule. The array key should be the input field name, and the value should be an array where each key is a validation rule name, and the value is the corresponding error message.

If no custom error messages are provided, a default error message will be used, such as Validation failed for field: 'email', while validating [email].

public array<string,array<string,string>> $messages = [];

Methods

validate

Do the validation based on defined rules and input request body.

public validate(array<string,mixed> $input, ?array<string,string> $rules = null): bool

Parameters:

Return Value:

bool - Returns true if all validation rules are passed, otherwise false.

isPassed

Check if all validation rules passed.

public isPassed(): bool

Return Value:

bool - Returns true if all validation rules are passed, otherwise false.

setRules

Set validation fields and rules.

public setRules(array<int,string> $rules): self

Parameters:

Return Value:

self - Return instance of the Validation class.

setMessages

Set validation error messages based on fields and ruels.

public setMessages(array<string,array> $messages = []): self

Parameters:

Return Value:

self - Return instance of the Validation class.

addField

Set a field and rules with an optional error messages.

This method can be called multiple times with different field name and rule.For $messages arguments, the array key will be the rule's name while the value is the message to display if form field fails the validation rule.

public addField(string $field, string $rules, array<string,string> $messages = []): self

Parameters:

Return Value:

self - Return instance of the Validation class.

getErrors

Get all validation error messages.

public getErrors(): array

Return Value:

array<string,array> - Return array of validation error messages, otherwise empty array.

getError

Get the error message at the specified field and error rules index.

public getError(string|int $fieldIndex = 0, int $errorIndex = 0): string

Parameters:

Return Value:

string - Return an error message.

getErrorMessage

Get the error message for a specific input field or using field index position.

public getErrorMessage(string|int $fieldIndex = 0): string;

Parameters:

Return Value:

string - Return an error message for the specified field.

getErrorField

Get the first field that has validation error.

public getErrorField(string|int $fieldIndex = 0): string

Parameters:

Return Value:

string - Return the field name causing the validation error.

getErrorFields

Get information about the validation error at the specified field index or field name.

When passed an integer index, it will return the first validation error.When passed a string field name, it will return the validation error related to that field name.

public getErrorFields(string|int $fieldIndex = 0): array

Parameters:

Return Value:

array<int,array> - Return array error information related to the field validation.

Validation Rules

These rules provide useful validation for various types of data, ensuring that your application processes only valid and expected input.