Livewire Combined Request Laravel Package

Getting Started

1. Installation: Add the package via Composer:

   composer require maskow/livewire-combined-request
   

2. First Use Case: Create a unified request class for a Livewire form and API endpoint:

   // app/Http/Requests/UpdatePostRequest.php
   class UpdatePostRequest extends CombinedFormRequest {
       protected array $requiredParameters = ['post'];
       public function rules() { return ['title' => 'required|string']; }
   }
   

3. Validate in Livewire:

   // In Livewire component
   $validated = UpdatePostRequest::validateLivewire($this, ['post' => $this->post]);
   

4. Use in Controller:

   // In HTTP controller
   public function update(UpdatePostRequest $request, Post $post) { ... }
   

Implementation Patterns

1. Unified Validation Workflow

• HTTP Context: Use standard Laravel route model binding

  Route::put('/posts/{post}', [PostController::class, 'update']);
  

• Livewire Context: Pass parameters explicitly

  UpdatePostRequest::validateLivewire($this, ['post' => $this->post]);
  

2. Parameter Handling

• Route Binding: Automatically resolves post from route
• Livewire Injection: Manually pass post model
• Access: Use $request->parameter('post') in both contexts

3. Authorization Pattern

• Single authorize() method handles both HTTP and Livewire

  public function authorize() {
      return $this->parameter('post')->user_id === auth()->id();
  }
  

4. File Uploads

• Works with Livewire's temporary files:

  public function rules() {
      return ['image' => 'required|image|mimes:jpeg,png'];
  }
  

5. Data Transformation

• Enable camelCase conversion in AppServiceProvider:

  CombinedFormRequest::convertCamelCaseToSnakeCase(true);
  

• Livewire properties (firstName) automatically map to snake_case rules (first_name)

6. Error Handling

• Global Livewire authorization notifications:

  CombinedFormRequest::notifyAuthorizationUsing(function($component, $message) {
      $component->dispatch('notify', ['type' => 'error', 'message' => $message]);
  });
  

Gotchas and Tips

Common Pitfalls

1. Missing Parameters:

   • Always pass all required parameters in Livewire:

     // ❌ Will throw exception
     UpdatePostRequest::validateLivewire($this);
     
     // ✅ Correct
     UpdatePostRequest::validateLivewire($this, ['post' => $this->post]);
     

   • Exception message helps identify missing parameters

2. CamelCase Conversion:

   • Default is disabled (backward compatibility)
   • Enable only when needed:

     CombinedFormRequest::convertCamelCaseToSnakeCase(true);
     

   • Verify error messages reference original camelCase property names

3. Route Model Binding:

   • Ensure route parameters match $requiredParameters
   • Example route: posts/{post} for ['post'] requirement

4. Livewire Property Names:

   • If using camelCase conversion, property names must match exactly
   • Example: firstName → first_name rule, but errors show firstName

Debugging Tips

1. Parameter Inspection:

   dd($this->parameters()); // Check all available parameters
   dd($this->parameter('post')); // Inspect specific parameter
   

2. Validation Debugging:

   try {
       $validated = UpdatePostRequest::validateLivewire($this, ['post' => $this->post]);
   } catch (\Illuminate\Validation\ValidationException $e) {
       dd($e->errors()); // Inspect validation errors
   }
   

3. Authorization Debugging:

   • Temporarily modify authorize() to return true for testing
   • Check parameter values with dd($this->parameter('post'))

Extension Points

1. Custom Parameter Resolution:

   • Override resolveParameter() in your request class:

     protected function resolveParameter(string $name, $default = null) {
         return $this->customLogic($name, $default);
     }
     

2. Data Transformation:

   • Use prepareForValidation() to modify data before validation:

     protected function prepareForValidation() {
         $this->merge(['slug' => Str::slug($this->title)]);
     }
     

3. Post-Validation Logic:

   • Use passedValidation() for side effects:

     protected function passedValidation() {
         activity()->log('Post updated', ['post_id' => $this->parameter('post')->id]);
     }
     

4. Global Configuration:

   • Set default behavior in AppServiceProvider:

     CombinedFormRequest::setDefaultDataFormat('camelCase'); // or 'snake_case'
     

Performance Considerations

• Avoid Over-Fetching: Only pass necessary parameters to Livewire validation
• Cache Request Classes: Laravel's request caching works normally
• Authorization: Keep authorization logic simple to avoid performance bottlenecks

Testing Strategies

1. Unit Test Validation:

   public function test_validation_rules() {
       $request = new UpdatePostRequest();
       $request->merge(['title' => '']);
       $this->assertFalse($request->validate());
   }
   

2. Livewire Test Double:

   $component = new EditPostComponent();
   $component->post = $post;
   $validated = UpdatePostRequest::validateLivewire($component, ['post' => $post]);
   

3. Authorization Testing:

   $request = new UpdatePostRequest();
   $request->setParameter('post', $post);
   $this->assertFalse($request->authorize());