Livewire Combined Request Laravel Package

Getting Started

Minimal Steps

1. Installation: Add the package via Composer:

   composer require maskow/livewire-combined-request
   

2. Create a Request Class: Extend CombinedFormRequest and define rules(), authorize(), and requiredParameters:

   use Maskow\CombinedRequest\CombinedFormRequest;
   
   class StorePostRequest extends CombinedFormRequest {
       protected array $requiredParameters = ['user'];
       public function rules() { return ['title' => 'required|string']; }
       public function authorize() { return true; }
   }
   

3. Use in HTTP Controller:

   public function store(StorePostRequest $request) {
       $validated = $request->validated();
       // ...
   }
   

4. Use in Livewire Component:

   public function save() {
       $validated = StorePostRequest::validateLivewire($this, ['user' => $this->user]);
       // ...
   }
   

First Use Case

Scenario: A form in a Livewire component that needs identical validation to an API endpoint. Solution:

1. Create a StorePostRequest with shared rules.
2. Use it in both the Livewire component (validateLivewire()) and HTTP controller (automatic validation).
3. Reuse authorize() logic across contexts.

Implementation Patterns

Unified Validation Workflow

1. HTTP Context:

   // Route: POST /posts
   Route::post('/posts', [PostController::class, 'store']);
   

   // Controller
   public function store(StorePostRequest $request) {
       // $request->validated() contains validated data
   }
   

2. Livewire Context:

   // Component
   public function save() {
       $validated = StorePostRequest::validateLivewire($this, [
           'user' => $this->user,
       ]);
       // $validated matches HTTP validation
   }
   

Parameter Binding Patterns

• Route Model Binding (HTTP):

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

  // Controller
  public function update(StorePostRequest $request, User $user) {
      $user = $request->parameter('user'); // Same as $user from route
  }
  

• Manual Injection (Livewire):

  // Component
  public function save() {
      $validated = StorePostRequest::validateLivewire($this, [
          'user' => $this->user,
          'post' => $this->post,
      ]);
  }
  

File Uploads

1. HTTP Context:

   public function store(StorePostRequest $request) {
       $file = $request->file('image');
       // Handle upload
   }
   

2. Livewire Context:

   public function save() {
       $validated = StorePostRequest::validateLivewire($this, [
           'user' => $this->user,
       ], ['image' => $this->image]); // LivewireUploadedFile
   }
   

Authorization Patterns

• Shared Logic:

  public function authorize() {
      return $this->parameter('user')->can('create', Post::class);
  }
  

• Livewire Notifications:

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

CamelCase Conversion (Optional)

1. Enable Globally:

   // AppServiceProvider
   CombinedFormRequest::convertCamelCaseToSnakeCase(true);
   

2. Livewire Component:

   public string $firstName = '';
   public string $lastName = '';
   

3. Request Rules:

   public function rules() {
       return [
           'first_name' => 'required', // Automatically maps to $firstName
           'last_name' => 'required',
       ];
   }
   

Gotchas and Tips

Pitfalls

1. Missing Required Parameters:

   • Error: Missing required parameters for App\Http\Requests\StorePostRequest: user.
   • Fix: Ensure all requiredParameters are passed in Livewire:

     StorePostRequest::validateLivewire($this, ['user' => $this->user]);
     

   • Debug: Check requiredParameters array in your request class.

2. Route Model Binding Mismatch:

   • Issue: HTTP routes must match requiredParameters names for automatic binding.
   • Example: If requiredParameters = ['user'], the route must include {user}.

3. CamelCase Conversion Overhead:

   • Warning: Enabling convertCamelCaseToSnakeCase adds minor performance overhead.
   • Tip: Disable it if not needed (false by default).

4. Livewire Property Naming:

   • Gotcha: If using camelCase conversion, ensure Livewire properties match expected snake_case rules.
   • Example: $emailAddress → email_address in rules.

5. Authorization Failures:

   • Silent Failures: Livewire won’t throw exceptions; use the global notifier or check $validated for null.

Debugging Tips

1. Validate Parameters:

   try {
       $validated = StorePostRequest::validateLivewire($this, ['user' => $this->user]);
   } catch (\InvalidArgumentException $e) {
       dd($e->getMessage()); // Debug missing parameters
   }
   

2. Inspect Validated Data:

   dd(StorePostRequest::validateLivewire($this, ['user' => $this->user]));
   

3. Check Parameter Access:

   dd($request->parameters()); // List all available parameters
   

Configuration Quirks

1. Global CamelCase Conversion:

   • Default: Disabled (false).
   • Enable: Set to true in AppServiceProvider for all requests.
   • Override: Disable per-request by extending CombinedFormRequest and overriding shouldConvertCamelCase().

2. Return Data Format:

   • Default: Returns data in camelCase (matches Livewire properties).
   • SnakeCase: Override getValidatedData() in your request class to return snake_case for database operations.

3. File Handling:

   • Livewire: Pass LivewireUploadedFile objects directly in the parameters array.
   • HTTP: Files are automatically handled via $request->file().

Extension Points

1. Custom Parameter Resolution:

   • Override resolveParameter() to add logic for resolving parameters dynamically.

   protected function resolveParameter($name, $default = null) {
       if ($name === 'current_user') {
           return auth()->user();
       }
       return parent::resolveParameter($name, $default);
   }
   

2. Validation Hooks:

   • Extend standard Laravel hooks (prepareForValidation, withValidator, passedValidation) for cross-context logic.

3. Custom Error Handling:

   • Override failedValidation() to customize error responses in Livewire.

   public static function validateLivewire($component, array $parameters = [], array $data = []) {
       try {
           $validated = parent::validateLivewire($component, $parameters, $data);
           return $validated;
       } catch (\Illuminate\Validation\ValidationException $e) {
           $component->addErrors($e->errors());
           return null;
       }
   }
   

4. Parameter Defaults:

   • Set defaults in requiredParameters:

   protected array $requiredParameters = [
       'user' => auth()->user(), // Default value
       'optional_param' => null,
   ];