Livewire Combined Request Laravel Package

Technical Evaluation

Architecture Fit

• High cohesion with Laravel/Livewire patterns: The package aligns perfectly with Laravel’s FormRequest ecosystem and Livewire’s component-based architecture, eliminating duplication between HTTP and Livewire validation logic.
• Unified validation layer: Centralizes validation rules, authorization, and parameter handling, reducing technical debt and improving maintainability.
• Extensibility: Leverages Laravel’s existing FormRequest hooks (prepareForValidation, withValidator, etc.), ensuring compatibility with custom validation logic.
• Context-agnostic design: Abstracts differences between HTTP route binding and Livewire manual injection, providing a seamless API for both contexts.

Integration Feasibility

• Minimal boilerplate: Zero configuration required; drop-in replacement for existing FormRequests.
• Backward compatibility: Works alongside standard Laravel FormRequests and Livewire components without breaking existing code.
• Livewire 3/4 support: Explicitly tested with both versions, reducing version-specific risks.
• PHP 8.1+ requirement: Aligns with Laravel 10/11/12’s baseline, ensuring compatibility with modern PHP features (e.g., named arguments, enums).

Technical Risk

• Livewire version lock-in: While supporting Livewire 3/4, future versions (e.g., 5+) may require updates. Monitor Livewire’s roadmap for breaking changes.
• CamelCase conversion overhead: Optional feature adds complexity if enabled globally. Disable by default to avoid unintended side effects.
• Parameter binding assumptions: Relies on route model binding for HTTP contexts and manual injection for Livewire. Misconfigured routes or missing parameters may cause runtime errors.
• Error handling granularity: Global authorization notifiers (e.g., toast messages) require explicit setup in AppServiceProvider. Overlooking this could lead to poor UX for failed authorizations.

Key Questions

1. Validation consistency: How will the team handle cases where Livewire component properties (camelCase) diverge from validation rules (snake_case)? Will the camelCase conversion feature be enabled globally?
2. Parameter management: What’s the strategy for handling optional vs. required parameters in complex workflows (e.g., nested forms, multi-step processes)?
3. Testing coverage: Does the team have a plan to test both HTTP and Livewire paths thoroughly, especially edge cases like missing parameters or authorization failures?
4. Performance impact: For high-traffic APIs, does the unified validation layer introduce measurable overhead compared to separate FormRequests?
5. Migration path: How will existing FormRequests be refactored to use CombinedFormRequest? Will this be a phased rollout or a big-bang change?

Integration Approach

Stack Fit

• Laravel 10/11/12: Native support with no framework modifications required.
• Livewire 3/4: Explicit compatibility; no additional Livewire plugins needed.
• PHP 8.1+: Leverages modern PHP features (e.g., union types, attributes) for cleaner code.
• API-first compatibility: Works seamlessly with Laravel Sanctum/Passport for API validation.
• Blade/Livewire hybrid apps: Ideal for applications mixing traditional Blade forms and Livewire components.

Migration Path

1. Phase 1: Pilot with non-critical components
   • Start with a single Livewire component and its corresponding HTTP controller.
   • Refactor their FormRequests to extend CombinedFormRequest.
   • Validate that validation rules, authorization, and parameter handling work identically in both contexts.
2. Phase 2: Incremental adoption
   • Prioritize components with duplicated validation logic (e.g., forms with both API and UI paths).
   • Update routes to ensure required parameters are bound correctly (e.g., {workspace}/teams/{team}).
   • Gradually replace validate() calls in Livewire components with validateLivewire().
3. Phase 3: Global enablement
   • Enable camelCase conversion (if needed) in AppServiceProvider.
   • Set up global authorization notifiers for Livewire.
   • Deprecate legacy FormRequests in favor of CombinedFormRequest.

Compatibility

• Existing FormRequests: Can coexist with standard FormRequest classes; no forced migration.
• Third-party packages: No known conflicts with popular Laravel/Livewire packages (e.g., Laravel Fortify, Spatie Validation).
• Custom validation logic: Supports all Laravel FormRequest hooks (prepareForValidation, withValidator, etc.).
• File uploads: Explicit support for Livewire’s file handling (e.g., $this->validate() with file fields).

Sequencing

1. Installation: composer require maskow/livewire-combined-request.
2. Refactor FormRequests: Extend CombinedFormRequest and define $requiredParameters.
3. Update HTTP routes/controllers: Ensure route model binding matches required parameters.
4. Update Livewire components: Replace validate() with validateLivewire() and pass parameters.
5. Test edge cases: Validate missing parameters, authorization failures, and file uploads.
6. Enable optional features: CamelCase conversion, global notifiers (if needed).

Operational Impact

Maintenance

• Reduced duplication: Single source of truth for validation rules, authorization, and parameter requirements.
• Centralized updates: Changes to validation logic (e.g., new rules, error messages) require updates in one place.
• Lower cognitive load: Developers only need to understand one validation system for both HTTP and Livewire.
• Documentation burden: Minimal; leverages existing Laravel/Livewire documentation.

Support

• Consistent error handling: Validation errors and authorization failures follow the same patterns across contexts.
• Debugging tools: Standard Laravel validation error messages and Livewire’s built-in error display.
• Parameter validation: Clear error messages for missing required parameters (e.g., "Missing required parameters: team, workspace").
• Global notifiers: Customizable authorization failure handling (e.g., toast messages, flash sessions).

Scaling

• Performance: Minimal overhead; validation logic is shared between contexts.
• Concurrency: No shared state between HTTP and Livewire requests; safe for high-traffic applications.
• Caching: Validation rules and authorization logic can be cached like standard FormRequests.
• Microservices: Works in monolithic and microservice architectures (e.g., API-only Laravel services).

Failure Modes

Ramp-Up

• Developer onboarding: Minimal learning curve; familiar Laravel FormRequest API.
• Training needs: Focus on:
  • Defining $requiredParameters.
  • Using validateLivewire() in components.
  • Accessing parameters via $this->parameter().
• Documentation gaps: Package README is comprehensive, but internal docs may need to highlight:
  • Migration steps from legacy FormRequests.
  • Best practices for parameter management.
  • CamelCase conversion trade-offs.
• Tooling support: IDE autocompletion for CombinedFormRequest methods (e.g., parameter(), validateLivewire()).
• Testing: Encourage unit tests for FormRequests (e.g., mocking parameter() calls) and component tests for Livewire validation.