Validator Bundle Laravel Package

Getting Started

Minimal Setup

1. Installation Add the bundle via Composer:

   composer require aaronadal/validator-bundle
   

   Enable it in config/bundles.php (Symfony):

   return [
       // ...
       Aaronadal\ValidatorBundle\AaronadalValidatorBundle::class => ['all' => true],
   ];
   

2. Basic Usage Inject the validator service into a controller or service:

   use Aaronadal\Validator\Validator;
   
   class MyController extends AbstractController
   {
       public function __construct(private Validator $validator) {}
   
       public function validate(Request $request)
       {
           $data = $request->request->all();
           $errors = $this->validator->validate($data, [
               'name' => 'required|string|min:3',
               'email' => 'required|email',
           ]);
   
           if ($errors) {
               // Handle validation errors
           }
       }
   }
   

3. First Use Case Validate form submissions in a Symfony controller:

   $validator = $this->validator;
   $data = $request->all();
   $rules = [
       'username' => 'required|string|max:20|unique:users,username',
       'password' => 'required|string|min:8',
   ];
   
   $errors = $validator->validate($data, $rules);
   

Implementation Patterns

Common Workflows

1. Form Validation Reuse rules across controllers by defining them in a dedicated service:

   // src/Validator/Rules.php
   class FormRules {
       public function getUserRules(): array {
           return [
               'name' => 'required|string|min:3',
               'email' => 'required|email|unique:users,email',
           ];
       }
   }
   

   Inject FormRules into controllers and pass its methods to the validator.

2. API Request Validation Validate JSON payloads in API endpoints:

   $json = json_decode($request->getContent(), true);
   $errors = $validator->validate($json, [
       'data' => 'required|array',
       'data.*' => 'required|string|max:255',
   ]);
   

3. Dynamic Rules Build rules dynamically based on request parameters:

   $rules = [
       'field' => 'required|' . ($request->get('type') === 'admin' ? 'admin_field' : 'user_field'),
   ];
   

Integration Tips

• Symfony Validator Bridge Extend Symfony’s built-in validator by adding custom rules:

  $validator->extend('custom_rule', function ($value, $constraint, $parameters) {
      return str_contains($value, $parameters[0]);
  });
  

  Use in rules: 'field' => 'required|custom_rule:prefix'.

• Event Listeners Validate data before saving to the database:

  // src/EventListener/ValidationListener.php
  class ValidationListener implements KernelEventListener {
      public function __construct(private Validator $validator) {}
  
      public function onKernelRequest(GetResponseEvent $event) {
          if ($event->isMainRequest() && $event->getRequest()->isMethod('POST')) {
              $data = $event->getRequest()->request->all();
              $errors = $validator->validate($data, ['field' => 'required']);
              if ($errors) throw new \RuntimeException('Validation failed');
          }
      }
  }
  

• Dependency Injection Bind the validator to a custom interface for easier testing:

  // config/services.yaml
  services:
      App\Validator\ValidatorInterface: '@aaronadal.validator'
  

Gotchas and Tips

Pitfalls

1. Rule Syntax Mismatch The package uses a custom rule syntax (e.g., |min:3), which may differ from Symfony’s Validator constraints. Double-check the validator library’s docs for supported rules.

2. Unique Rule Quirks The unique rule may not support table prefixes or complex queries out of the box. For advanced use cases, extend the validator:

   $validator->extend('unique', function ($value, $constraint, $parameters) {
       list($table, $column) = $parameters;
       return !DB::table($table)->where($column, $value)->exists();
   });
   

3. Error Handling The validate() method returns an array of errors, but it may not follow Symfony’s ConstraintViolationListInterface. Convert errors manually if needed:

   $violations = collect($errors)->map(function ($error) {
       return new ConstraintViolation(
           $error['message'],
           $error['field'],
           [],
           null,
           $error['field'],
           $error['value']
       );
   });
   

4. Performance Avoid validating the same data multiple times. Cache rules or reuse validator instances:

   $validator = $container->get('aaronadal.validator');
   $validator->setRules($rules); // Reuse rules for multiple validations
   

Debugging

• Enable Debug Mode Set AARONADAL_VALIDATOR_DEBUG to true in .env to log validation rules and errors:

  AARONADAL_VALIDATOR_DEBUG=1
  

• Rule Validation Test rules individually in a twig template or php artisan tinker:

  $validator->validate(['field' => 'test'], ['field' => 'required|min:5']);
  

Extension Points

1. Custom Rules Add rules dynamically at runtime:

   $validator->extend('starts_with', function ($value, $constraint, $parameters) {
       return str_starts_with($value, $parameters[0]);
   });
   

2. Message Customization Override default error messages:

   $validator->setMessages([
       'required' => 'The :field is mandatory!',
       'email' => 'The :field must be a valid email address.',
   ]);
   

3. Integration with Symfony Forms Use the validator with Symfony’s FormBuilder:

   $builder->add('field', TextType::class, [
       'constraints' => [
           new CustomConstraint(['rule' => 'required|custom_rule']),
       ],
   ]);
   

   (Requires mapping the validator’s rules to Symfony constraints.)

4. Localization Support multiple languages by binding messages to a translation service:

   $validator->setTranslator($translator);
   $validator->setMessages([
       'required' => 'validator.required',
   ]);