# How to Use Multiple Custom Rules from laravel-validate in a Laravel Request

> Learn to combine multiple custom rules from laravel-validate in your Laravel requests. Instantiate rule classes directly or use string-based validation for flexible form request validation.

- Repository: [Milwad Khosravi/laravel-validate](https://github.com/milwad-dev/laravel-validate)
- Tags: how-to-guide
- Published: 2026-03-07

---

**You can combine any number of custom rules from the `milwad-dev/laravel-validate` package by instantiating the rule classes directly in a Form Request's `rules()` method or by using string-based validation when `using_container` is enabled in the config.**

The `milwad-dev/laravel-validate` package provides dozens of pre-built validation rules for common patterns like phone numbers, UUIDs, and strong passwords. When building complex Laravel applications, you often need to validate several custom fields simultaneously within a single request class.

## Architecture Overview of laravel-validate Rules

Each rule in the package lives in `src/Rules/` and implements Laravel's `Illuminate\Contracts\Validation\Rule` interface. The `LaravelValidateServiceProvider` (located at [`src/LaravelValidateServiceProvider.php`](https://github.com/milwad-dev/laravel-validate/blob/main/src/LaravelValidateServiceProvider.php)) handles registration. When the `using_container` config option is set to `true`, the provider automatically iterates over all files in `src/Rules` and registers them with the `Validator` facade:

```php
$rules = File::files(__DIR__.'/Rules');
foreach ($rules as $rule) {
    $className = 'Milwad\\LaravelValidate\\Rules\\'.$rule->getBasename('.php');
    Validator::extend(
        $rule->getFilenameWithoutExtension(),
        fn($attr,$value,$params,$validator) => (new $className($params))->passes($attr,$value)
    );
}

```

This architecture allows you to use the rules either as instantiated objects or as strings, depending on your configuration preference.

## Method 1: Instantiating Rule Objects Directly (Recommended)

The most explicit and flexible approach is to import the rule classes and instantiate them in your Form Request. This method works regardless of the `using_container` setting and allows you to pass constructor arguments (such as country codes for phone validation).

### Complete Form Request Example

Below is a practical implementation combining `ValidPhoneNumber`, `ValidUuid`, and `ValidStrongPassword` in a single `RegisterUserRequest`:

```php
<?php

namespace App\Http\Requests;

use Illuminate\Foundation\Http\FormRequest;
use Milwad\LaravelValidate\Rules\ValidPhoneNumber;
use Milwad\LaravelValidate\Rules\ValidUuid;
use Milwad\LaravelValidate\Rules\ValidStrongPassword;

class RegisterUserRequest extends FormRequest
{
    public function authorize(): bool
    {
        return true;
    }

    public function rules(): array
    {
        return [
            'name' => ['required', 'string', 'max:255'],
            
            // Validates Iranian phone numbers via constructor argument
            'phone' => [
                'required',
                new ValidPhoneNumber('IR'),
            ],
            
            // Ensures the reference ID is a valid UUID
            'ref_id' => [
                'required',
                new ValidUuid(),
            ],
            
            // Enforces strong password policy (upper, lower, digit, special)
            'password' => [
                'required',
                'string',
                'min:8',
                new ValidStrongPassword(),
            ],
        ];
    }
}

```

In this example, `ValidPhoneNumber` accepts a country code parameter that routes to the appropriate callback defined in [`src/Utils/CountryPhoneCallback.php`](https://github.com/milwad-dev/laravel-validate/blob/main/src/Utils/CountryPhoneCallback.php). The `ValidUuid` class (located at [`src/Rules/ValidUuid.php`](https://github.com/milwad-dev/laravel-validate/blob/main/src/Rules/ValidUuid.php)) validates UUID v4 strings, while `ValidStrongPassword` (at [`src/Rules/ValidStrongPassword.php`](https://github.com/milwad-dev/laravel-validate/blob/main/src/Rules/ValidStrongPassword.php)) checks for character diversity.

## Method 2: String-Based Validation with Container Registration

If you prefer the traditional Laravel string syntax and have enabled `using_container` in [`config/laravel-validate.php`](https://github.com/milwad-dev/laravel-validate/blob/main/config/laravel-validate.php), the service provider automatically registers rule names that match the class names. This allows you to use pipe-delimited validation strings:

```php
public function rules(): array
{
    return [
        'phone'    => 'required|ValidPhoneNumber:IR',
        'ref_id'   => 'required|ValidUuid',
        'password' => 'required|min:8|ValidStrongPassword',
    ];
}

```

The `LaravelValidateServiceProvider` maps these strings to the underlying classes through the extension callback shown in the architecture section. Parameters after the colon (such as `IR`) are passed to the rule's constructor.

## Key Implementation Details

### Country-Specific Validation Callbacks

The `ValidPhoneNumber` and `ValidLandlineNumber` rules rely on dynamic callbacks for country-specific formatting. These are managed by [`src/Utils/CountryPhoneCallback.php`](https://github.com/milwad-dev/laravel-validate/blob/main/src/Utils/CountryPhoneCallback.php) and [`src/Utils/CountryLandlineCallback.php`](https://github.com/milwad-dev/laravel-validate/blob/main/src/Utils/CountryLandlineCallback.php), which map country codes to validator classes. When you pass `'IR'` to `ValidPhoneNumber`, the rule delegates validation to the Iranian phone validator registered in the callback utility.

### Rule Class Structure

All custom rules implement `Illuminate\Contracts\Validation\Rule`, ensuring compatibility with Laravel's validator. The package source shows consistent patterns across [`src/Rules/ValidUuid.php`](https://github.com/milwad-dev/laravel-validate/blob/main/src/Rules/ValidUuid.php), [`src/Rules/ValidStrongPassword.php`](https://github.com/milwad-dev/laravel-validate/blob/main/src/Rules/ValidStrongPassword.php), and [`src/Rules/ValidPhoneNumber.php`](https://github.com/milwad-dev/laravel-validate/blob/main/src/Rules/ValidPhoneNumber.php): each defines a `passes()` method for logic and a `message()` method for error text, with translation keys supporting localization.

## Summary

- **Instantiate directly** for maximum flexibility and constructor arguments; this works regardless of configuration settings.
- **Enable `using_container`** in [`config/laravel-validate.php`](https://github.com/milwad-dev/laravel-validate/blob/main/config/laravel-validate.php) to use string-based validation syntax like `ValidPhoneNumber:IR`.
- **Combine freely** with native Laravel rules (`required`, `email`, `min:8`) in any Form Request.
- **Reference the source** in `src/Rules/`, [`src/LaravelValidateServiceProvider.php`](https://github.com/milwad-dev/laravel-validate/blob/main/src/LaravelValidateServiceProvider.php), and `src/Utils/` for implementation details.

## Frequently Asked Questions

### Can I use laravel-validate rules without enabling the container?

Yes. You can instantiate the rule classes directly in your Form Request's `rules()` method using the `new` keyword. This approach bypasses the container registration entirely and allows you to pass constructor arguments, such as country codes for phone validation.

### How do I pass parameters to custom rules when using string syntax?

When `using_container` is enabled, append parameters after a colon in the validation string. For example, `ValidPhoneNumber:IR` passes `IR` as the constructor argument to the `ValidPhoneNumber` class. Multiple parameters can be separated by commas if the rule supports them.

### Are the validation messages translatable?

Yes. All rule classes in `src/Rules/` implement the `message()` method to return translation keys. The package publishes language files that you can customize, allowing you to localize error messages for `ValidStrongPassword`, `ValidUuid`, and other rules according to your application's locale.

### Which Laravel versions are supported by milwad-dev/laravel-validate?

The package supports modern Laravel versions that use the `Illuminate\Contracts\Validation\Rule` interface. The service provider and rule implementations are compatible with Laravel 8.x through 11.x, utilizing standard validation contracts that have remained consistent across recent releases.