Custom validation rules in Laravel - Deep Dive

Overview - Custom validation rules

What is it?

Custom validation rules in Laravel let you create your own checks to decide if data is valid or not. Instead of only using built-in rules like 'required' or 'email', you can write rules that fit your specific needs. This helps make sure the data your app gets is exactly what you expect. It’s like setting your own standards for what counts as good data.

Why it matters

Without custom validation rules, you would be stuck with only the basic checks Laravel provides. This means you might accept wrong or incomplete data, causing bugs or security problems. Custom rules let you protect your app by making sure data fits your unique requirements, improving reliability and user trust.

Where it fits

Before learning custom validation rules, you should understand Laravel’s basic validation system and how to use built-in rules. After mastering custom rules, you can explore advanced validation features like form requests and conditional validation to build robust data checks.

Mental Model

Core Idea

Custom validation rules are your own data tests that plug into Laravel’s validation system to check data exactly how you want.

Think of it like...

It’s like setting your own house rules for guests instead of just following general etiquette. You decide what’s allowed and what’s not, making sure everything fits your unique style.

┌───────────────────────────────┐
│       Laravel Validation       │
│ ┌───────────────┐             │
│ │ Built-in Rules│             │
│ └───────────────┘             │
│           ▲                   │
│           │                   │
│ ┌─────────────────────────┐  │
│ │ Custom Validation Rules │  │
│ └─────────────────────────┘  │
└───────────────────────────────┘

Build-Up - 7 Steps

1

Foundation

Understanding Laravel Validation Basics

Concept: Learn how Laravel validates data using built-in rules.

Laravel uses a Validator class to check if data meets certain rules like 'required', 'email', or 'max'. You pass data and rules to the validator, and it tells you if the data is valid or not. For example, validating a user’s email to be required and properly formatted.

Result

You can quickly check if data fits common patterns and reject bad input.

Understanding built-in validation is essential before creating your own rules because custom rules build on this system.

2

Foundation

How to Use Validation in Controllers

Concept: Learn where and how to apply validation in Laravel apps.

In Laravel controllers, you call $request->validate() with rules to check incoming data. If validation fails, Laravel automatically redirects back with errors. This keeps your app safe from bad data early in the request.

Result

Your app stops invalid data before it causes problems.

Knowing how validation fits into request handling helps you see where custom rules will plug in.

3

Intermediate

Creating Simple Custom Validation Rules

🤔Before reading on: do you think custom rules must be classes or can they be closures? Commit to your answer.

Concept: Learn how to write a quick custom rule using a closure function.

Laravel lets you define custom rules inline using closures. For example, you can check if a username contains only letters by passing a closure to the 'validate' method. The closure receives the attribute name, value, and a fail callback to call if validation fails.

Result

You can add simple, one-off checks without creating full classes.

Knowing closures can be custom rules makes quick validations easy and flexible.

4

Intermediate

Building Custom Rule Classes

🤔Before reading on: do you think custom rule classes must implement an interface or just have a method? Commit to your answer.

Concept: Learn how to create reusable custom validation rules as classes.

Laravel allows you to create a rule class by running 'php artisan make:rule RuleName'. This class must implement the 'Illuminate\Contracts\Validation\Rule' interface, which requires a 'passes' method to check validity and a 'message' method to return an error message. You can then use this class in your validation rules.

Result

You get reusable, organized validation logic that can be tested and maintained easily.

Understanding the interface contract clarifies how Laravel expects custom rules to behave.

5

Intermediate

Passing Parameters to Custom Rules

🤔Before reading on: do you think custom rule classes can accept parameters in their constructor? Commit to your answer.

Concept: Learn how to customize rule behavior by passing data when creating rule instances.

You can add constructor parameters to your custom rule classes to accept extra data. For example, a rule checking if a number is within a dynamic range can accept min and max values. This makes rules flexible and adaptable to different situations.

Result

Your custom rules become more powerful and reusable with different settings.

Knowing how to pass parameters lets you avoid duplicating similar rules with small differences.

6

Advanced

Using Custom Rules with Form Request Classes

🤔Before reading on: do you think custom rules can be used inside Laravel Form Request classes? Commit to your answer.

Concept: Learn how to integrate custom validation rules into Laravel’s Form Request feature.

Form Requests are special classes that handle validation and authorization. You can use your custom rule classes inside the 'rules' method of a Form Request by returning instances of your rules. This keeps validation logic clean and reusable across controllers.

Result

Your validation code is organized, testable, and separated from controller logic.

Understanding this integration helps build maintainable Laravel apps with complex validation.

7

Expert

Optimizing Custom Rules for Performance and Localization

🤔Before reading on: do you think custom rules automatically support multiple languages? Commit to your answer.

Concept: Learn how to make custom rules efficient and support multiple languages for error messages.

Custom rules should avoid heavy computations inside the 'passes' method to keep validation fast. For localization, use Laravel’s translation functions inside the 'message' method to return error messages in the user’s language. Also, cache any expensive data if needed. This ensures your app scales well and is user-friendly worldwide.

Result

Your custom validation is fast and friendly to users in different languages.

Knowing performance and localization best practices prevents common pitfalls in production apps.

Under the Hood

Laravel’s validation system uses a Validator class that runs each rule’s check on the data. For custom rules, Laravel calls the 'passes' method on your rule class or executes your closure, passing the data to test. If the check returns false, Laravel collects the error message from your rule’s 'message' method or closure. This process happens during the request lifecycle before your controller logic proceeds.

Why designed this way?

Laravel’s validation was designed to be flexible and extensible. Built-in rules cover common cases, but developers often need custom logic. By allowing closures and rule classes with a simple interface, Laravel balances ease of use with power. This design avoids forcing developers to rewrite validation logic and keeps code clean and testable.

┌───────────────┐
│ Incoming Data │
└──────┬────────┘
       │
       ▼
┌───────────────┐
│ Validator     │
│ ┌───────────┐ │
│ │ Built-in  │ │
│ │ Rules     │ │
│ └───────────┘ │
│       ▲       │
│       │       │
│ ┌───────────┐ │
│ │ Custom    │ │
│ │ Rules     │ │
│ └───────────┘ │
└──────┬────────┘
       │
       ▼
┌───────────────┐
│ Validation    │
│ Result       │
└───────────────┘

Myth Busters - 4 Common Misconceptions

Quick: Do you think custom validation rules must always be classes? Commit to yes or no.

Common Belief: Custom validation rules must be full classes created with artisan commands.

Reality: You can create simple custom rules using closures without making classes.

Why it matters: Believing this limits quick fixes and makes beginners avoid easy solutions.

Quick: Do you think custom rules automatically handle error messages in all languages? Commit to yes or no.

Common Belief: Custom validation rules automatically support all languages without extra work.

Reality: You must explicitly use Laravel’s translation functions in your rule’s message method for localization.

Why it matters: Ignoring this causes error messages to appear only in one language, hurting user experience.

Quick: Do you think custom validation rules run after the controller logic? Commit to yes or no.

Common Belief: Custom validation rules run after the controller processes the data.

Reality: Validation, including custom rules, runs before controller logic to prevent bad data from entering your app.

Why it matters: Misunderstanding this can lead to security holes or bugs by trusting unvalidated data.

Quick: Do you think you can pass parameters to custom rule classes via the validation rules array? Commit to yes or no.

Common Belief: You cannot pass parameters to custom rule classes; they must be hardcoded.

Reality: You pass parameters by creating instances of the rule class with arguments in your validation rules array.

Why it matters: Not knowing this reduces flexibility and causes duplicated code.

Expert Zone

1

Custom rules can implement the 'ImplicitRule' interface to run even when the field is empty, useful for certain validations.

2

You can combine multiple custom rules in arrays to build complex validation logic without mixing concerns.

3

Custom rules can be tested independently with unit tests, improving code quality and reducing bugs.

When NOT to use

Avoid custom validation rules for very simple checks that built-in rules cover, to keep code simple. For complex validation involving multiple fields, consider using Form Request classes with 'withValidator' hooks or custom validation services instead.

Production Patterns

In real apps, custom rules often validate business logic like unique codes, external API checks, or format rules specific to the domain. They are used inside Form Requests for clean controllers and combined with localization for user-friendly error messages.

Connections

Design Patterns - Strategy Pattern

Custom validation rules implement the Strategy pattern by encapsulating validation logic in interchangeable classes.

Understanding this pattern helps you design flexible validation systems where rules can be swapped or combined easily.

User Experience Design

Custom validation rules improve UX by providing precise, meaningful feedback tailored to your app’s needs.

Knowing how validation affects user trust and error recovery helps you write rules that guide users smoothly.

Quality Assurance Testing

Custom validation rules can be unit tested separately to ensure correctness before deployment.

Recognizing validation as testable units improves software reliability and reduces bugs in production.

Common Pitfalls

#1 Creating a custom rule class without implementing the required interface.

Wrong approach:

class MyRule {
public function passes($attribute, $value) {
return true;
}
public function message() {
return 'Error message';
}
}

Correct approach:

use Illuminate\Contracts\Validation\Rule;
class MyRule implements Rule {
public function passes($attribute, $value) {
return true;
}
public function message() {
return 'Error message';
}
}

Root cause:

Not knowing Laravel requires custom rule classes to implement the Rule interface for validation to work.

#2 Returning a boolean true/false directly from a closure without calling the fail callback.

Wrong approach:

$request->validate([
'field' => [function($attribute, $value) {
return $value === 'yes';
}]
]);

Correct approach:

$request->validate([
'field' => [function($attribute, $value, $fail) {
if ($value !== 'yes') {
$fail('The '.$attribute.' must be yes.');
}
}]
]);

Root cause:

Misunderstanding that closures must call the fail callback to signal validation failure.

#3 Hardcoding error messages in custom rules without using translation functions.

Wrong approach:

public function message() {
return 'Invalid input';
}

Correct approach:

public function message() {
return __('validation.custom.invalid_input');
}

Root cause:

Ignoring Laravel’s localization system leads to messages that cannot adapt to user languages.

Key Takeaways

Custom validation rules let you create your own data checks beyond Laravel’s built-in options.

You can write quick rules using closures or reusable rules as classes implementing a simple interface.

Passing parameters to rule classes makes your validation flexible and adaptable to different needs.

Integrating custom rules with Form Requests keeps your code clean and maintainable.

Optimizing for performance and localization ensures your app is fast and user-friendly worldwide.