Validator Laravel Package

Getting Started

Minimal Setup

1. Installation

   composer require aaronadal/validator
   

   Publish the config (if needed):

   php artisan vendor:publish --provider="Aaronadal\Validator\ValidatorServiceProvider"
   

2. Define a Rule Set Create a validator class (e.g., app/Validators/UserValidator.php):

   namespace App\Validators;
   
   use Aaronadal\Validator\Validator;
   
   class UserValidator extends Validator
   {
       protected $rules = [
           'name' => 'required|string|max:255',
           'email' => 'required|email|unique:users',
           'password' => 'required|string|min:8',
       ];
   
       protected $messages = [
           'name.required' => 'The name field is required.',
           'email.unique' => 'This email is already taken.',
       ];
   }
   

3. First Use Case: Validate a Request

   use App\Validators\UserValidator;
   use Illuminate\Http\Request;
   
   public function store(Request $request)
   {
       $validator = new UserValidator($request->all());
       if ($validator->fails()) {
           return response()->json($validator->errors(), 422);
       }
       // Proceed with logic...
   }
   

Where to Look First

• Validator Class: Extend Aaronadal\Validator\Validator and define $rules and $messages.
• Validation Methods: fails(), passes(), errors(), and validated() (returns sanitized data).
• Custom Rules: Extend Aaronadal\Validator\Rules\Rule for reusable logic.

Implementation Patterns

1. Centralized Validation Logic

• Pattern: Define validators for domain-specific objects (e.g., UserValidator, OrderValidator).
• Example:

  // app/Validators/OrderValidator.php
  class OrderValidator extends Validator
  {
      protected $rules = [
          'items.*.product_id' => 'required|exists:products,id',
          'items.*.quantity' => 'required|integer|min:1',
          'shipping_address' => 'required|array',
      ];
  }
  

• Use Case: Reuse across API routes, form requests, and service layers.

2. Integration with Laravel Requests

• Pattern: Extend Illuminate\Foundation\Http\FormRequest and delegate validation.
• Example:

  use App\Validators\UserValidator;
  
  class StoreUserRequest extends FormRequest
  {
      public function validate()
      {
          $validator = new UserValidator($this->all());
          if ($validator->fails()) {
              throw new \Illuminate\Validation\ValidationException($validator->errors());
          }
          return $validator->validated();
      }
  }
  

3. Dynamic Rule Sets

• Pattern: Override rules dynamically based on context (e.g., admin vs. user).
• Example:

  $validator = new UserValidator($data);
  if (auth()->user()->isAdmin()) {
      $validator->addRule('email', 'required|unique:users,email,null,id');
  }
  

4. Error Handling

• Pattern: Format errors for APIs or UI.
• API Response:

  return response()->json([
      'errors' => $validator->errors()->toArray(),
  ], 422);
  

• UI Flash Messages:

  session()->flash('errors', $validator->errors()->toArray());
  

5. Testing Validators

• Pattern: Unit test validators in isolation.
• Example:

  public function test_validator_passes()
  {
      $validator = new UserValidator(['name' => 'John', 'email' => 'john@example.com']);
      $this->assertTrue($validator->passes());
  }
  

Gotchas and Tips

Pitfalls

1. Rule Syntax:

   • Uses Laravel’s native rule syntax (e.g., required|string|max:255), but ensure compatibility with the package’s parser.
   • Fix: Test edge cases like nested arrays (items.*.field) or custom rules.

2. Error Message Overrides:

   • Custom $messages in the validator class take precedence over Laravel’s default messages.
   • Tip: Use php artisan vendor:publish to inspect default messages if needed.

3. Immutable Data:

   • validated() returns sanitized data, but nested arrays may be flattened.
   • Workaround: Use $validator->getData() for raw input or manually reconstruct arrays.

4. Performance:

   • Avoid instantiating validators for every request if rules are static. Cache validator classes or reuse instances.
   • Example:

     $validator = app()->make(UserValidator::class); // Singleton-like behavior
     

Debugging Tips

1. Validate Raw Input:

   $validator = new UserValidator($request->all());
   dd($validator->errors()->toArray()); // Debug errors
   

2. Check Rule Parsing:

   • If rules fail silently, verify the $rules array syntax matches Laravel’s expectations.
   • Test: Use Validator::make($data, $rules) directly to isolate issues.

3. Custom Rules:

   • Ensure custom rules extend Aaronadal\Validator\Rules\Rule and implement passes().
   • Example:

     class CustomRule extends Rule
     {
         public function passes($attribute, $value)
         {
             return str_contains($value, 'test');
         }
     }
     

   • Register custom rules in the validator’s $rules:

     'field' => 'custom_rule_name',
     

Extension Points

1. Custom Error Formatters:

   • Extend Aaronadal\Validator\ErrorFormatter to modify error output (e.g., for GraphQL).
   • Example:

     class GraphQLErrorFormatter extends ErrorFormatter
     {
         public function format()
         {
             return ['errors' => $this->errors];
         }
     }
     

   • Bind it in AppServiceProvider:

     Validator::extend('formatter', function ($attribute, $value, $parameters) {
         return new GraphQLErrorFormatter($this->errors);
     });
     

2. Rule Macros:

   • Add reusable rule combinations:

     Validator::extend('strong_password', function ($attribute, $value) {
         return strlen($value) >= 12 && preg_match('/[A-Z]/', $value);
     });
     

   • Use in validators:

     'password' => 'required|strong_password',
     

3. Event Listeners:

   • Trigger events on validation (e.g., log failed validations):

     Validator::failing(function ($validator) {
         \Log::warning('Validation failed', ['errors' => $validator->errors()]);
     });