Http Bundle Laravel Package

Getting Started

Minimal Setup

1. Installation

   composer require dimkinthepro/http-bundle
   

   Add to config/bundles.php (Symfony) or config/app.php (Laravel via bridge):

   return [
       // ...
       DimkinThePro\HttpBundle\HttpBundle::class => ['all' => true],
   ];
   

2. Basic Usage Register the bundle in config/packages/dimkinthepro_http.yaml (Symfony) or config/http-bundle.php (Laravel):

   dimkinthepro_http:
       validation:
           enabled: true
   

3. First Use Case Validate an incoming request in a controller:

   use DimkinThePro\HttpBundle\Validator\RequestValidator;
   
   public function store(Request $request, RequestValidator $validator)
   {
       $validator->validate($request, [
           'name' => 'required|string|max:255',
           'email' => 'required|email',
       ]);
   
       // Proceed if valid
   }
   

Implementation Patterns

Core Workflows

1. Request Validation

   • Inline Validation:

     $validator->validate($request, $rules);
     

   • Reusable Rules: Define rules in a config file (config/validation_rules.php):

     return [
         'user.store' => [
             'name' => 'required|string|max:255',
             'email' => 'required|email|unique:users',
         ],
     ];
     

     Use in controller:

     $validator->validate($request, config('validation_rules.user.store'));
     

2. Custom Validation Logic Extend the validator with custom rules:

   use DimkinThePro\HttpBundle\Validator\Rules\CustomRule;
   
   class CustomRule extends CustomRule
   {
       public function passes($attribute, $value)
       {
           return str_contains($value, 'admin');
       }
   }
   

   Register in services.yaml (Symfony) or app/Providers/AppServiceProvider.php (Laravel):

   $this->app->bind(CustomRule::class);
   

3. Error Handling

   • Customize error responses via config:

     dimkinthepro_http:
         validation:
             error_format: 'api' # or 'array', 'json'
     

   • Override error messages:

     $validator->setMessages([
         'required' => 'The :attribute field is mandatory!',
     ]);
     

4. Integration with Forms Use with Symfony Forms or Laravel Form Requests:

   use DimkinThePro\HttpBundle\Validator\FormValidator;
   
   public function create(FormValidator $formValidator)
   {
       $form = $this->createForm(UserType::class);
       $form->handleRequest($request);
       $formValidator->validate($form);
   }
   

Gotchas and Tips

Common Pitfalls

1. Rule Syntax Conflicts

   • Ensure rules match Laravel/Symfony’s validation syntax (e.g., unique:table,column).
   • Fix: Test rules in isolation before bundling them.

2. Caching Issues

   • Config changes (e.g., rules) may not reflect immediately if cached.
   • Fix: Clear cache after updates:

     php artisan cache:clear
     

3. Dependency Overrides

   • The bundle assumes Laravel/Symfony’s validator under the hood. Conflicts may arise if using custom validators.
   • Fix: Bind the bundle’s validator explicitly:

     $this->app->bind(
         \DimkinThePro\HttpBundle\Validator\RequestValidator::class,
         fn() => new RequestValidator($this->app->make(\Illuminate\Validation\Factory::class))
     );
     

4. CSRF Token Validation

   • The bundle does not handle CSRF tokens by default. Add manually:

     $validator->validate($request, ['_token' => 'required']);
     

Pro Tips

1. Dynamic Rule Loading Load rules from a database or API:

   $rules = $this->fetchRulesFromDatabase($request->user());
   $validator->validate($request, $rules);
   

2. Performance Optimization Pre-compile rules for frequent validations:

   $compiledRules = $validator->compileRules($rules);
   $validator->validate($request, $compiledRules);
   

3. Testing Mock the validator in tests:

   $validator = $this->createMock(RequestValidator::class);
   $validator->method('validate')->willReturn(true);
   $this->app->instance(RequestValidator::class, $validator);
   

4. Extension Points

   • Events: Listen for validation.failed events to log or transform errors.
   • Middleware: Wrap validation in middleware for global use:

     public function handle($request, Closure $next)
     {
         $validator = app(RequestValidator::class);
         $validator->validate($request, config('validation_rules.global'));
         return $next($request);
     }
     

5. Debugging

   • Enable verbose error output:

     dimkinthepro_http:
         validation:
             debug: true
     

   • Check raw validation errors:

     try {
         $validator->validate($request, $rules);
     } catch (\DimkinThePro\HttpBundle\Exception\ValidationException $e) {
         dd($e->getErrors()); // Dump raw errors
     }