Verified Request Laravel Package

Getting Started

Minimal Setup

1. Installation

   composer require alex-dwt/verified-request
   

   Register the bundle in config/bundles.php (Symfony) or manually in AppServiceProvider (Laravel):

   // Laravel (if not auto-discovered)
   $this->app->register(AlexDwt\VerifiedRequestBundle\VerifiedRequestBundle::class);
   

2. First Use Case: Validating a Form Request Define a DTO (Data Transfer Object) class:

   namespace App\DTO;
   
   use AlexDwt\VerifiedRequestBundle\VerifiedRequest;
   
   class LoginRequest extends VerifiedRequest
   {
       public $email;
       public $password;
   
       public function rules()
       {
           return [
               'email' => 'required|email',
               'password' => 'required|min:6',
           ];
       }
   }
   

   Use it in a controller:

   use App\DTO\LoginRequest;
   
   public function login(LoginRequest $request)
   {
       // $request is now validated and populated
       return response()->json(['success' => true]);
   }
   

3. Key Files to Explore

   • src/VerifiedRequest.php: Core class for validation logic.
   • config/packages/alex_dwt_verified_request.yaml: Configuration (if any).

Implementation Patterns

Workflow: Request Validation Pipeline

1. DTO-Centric Validation

   • Create a DTO for every request type (e.g., CreateUserRequest, UpdateProfileRequest).
   • Extend VerifiedRequest and define rules() method using Symfony Validator constraints.

2. Dependency Injection

   • Laravel’s auto-wiring resolves VerifiedRequest objects automatically.
   • Example:

     public function store(CreateUserRequest $request) { ... }
     

3. Custom Validation Logic

   • Override validate() in DTO to add custom rules:

     public function validate()
     {
         $this->addViolation('custom.error', ['field' => $this->field]);
     }
     

4. Nested Objects

   • Validate nested DTOs by type-hinting properties:

     public $address; // Type-hinted as AddressRequest DTO
     

5. API Resource Integration

   • Use with Laravel’s JsonResource for consistent API responses:

     return new UserResource($this->userService->create($request));
     

Integration Tips

• Form Requests: Combine with Laravel’s FormRequest for hybrid validation:

  public function rules()
  {
      return array_merge(
          parent::rules(),
          ['csrf_token' => 'required']
      );
  }
  

• API Middleware: Validate API requests globally via middleware:

  public function handle($request, Closure $next)
  {
      $request->merge(new ApiRequest($request->all()));
      return $next($request);
  }
  

Gotchas and Tips

Pitfalls

1. Missing rules() Method

   • Forgetting to define rules() throws UndefinedMethodException.
   • Fix: Ensure all DTOs implement rules().

2. Circular Dependencies

   • Nested DTOs with circular references (e.g., User → Address → User) cause infinite loops.
   • Fix: Use lazy loading or break cycles with IDs.

3. Symfony Validator Conflicts

   • Conflicts with Laravel’s built-in validation if not careful.
   • Fix: Prefix constraints or use VerifiedRequest exclusively for DTOs.

4. Case Sensitivity

   • Field names in rules() must match DTO properties exactly (e.g., $email vs $Email).

Debugging

• Validation Errors: Check $request->errors() for failed constraints.
• Logging: Enable Symfony Validator debug mode:

  $validator = $this->getValidator();
  $validator->setConstraintValidatorFactory(new DebugValidatorFactory());
  

Extension Points

1. Custom Constraints

   • Create a custom validator and register it with Symfony’s validator:

     $validator->addMapping(new ConstraintMapping([
         new Assert\CustomConstraint() => ['property' => 'field'],
     ]));
     

2. Event Listeners

   • Hook into VerifiedRequest::VALIDATED event for post-validation logic:

     event(new VerifiedRequestEvent($request));
     

3. Configuration

   • Override default behavior via config/packages/alex_dwt_verified_request.yaml:

     alex_dwt_verified_request:
         strict_mode: true # Throws exceptions on validation failure
     

Pro Tips

• Reusable Rules: Extract common rules to a base DTO:

  abstract class BaseRequest extends VerifiedRequest
  {
      public function commonRules() { ... }
      public function rules() { return $this->commonRules(); }
  }
  

• Testing: Use VerifiedRequestTestCase for unit tests:

  $request = new LoginRequest(['email' => '[email protected]']);
  $this->assertTrue($request->isValid());