Laravel Support Laravel Package

Getting Started

Minimal Setup

1. Installation

   composer require rinvex/laravel-support
   

   Publish the config (if needed):

   php artisan vendor:publish --provider="Rinvex\Support\Providers\SupportServiceProvider"
   

2. First Use Case: Basic Validator Use the built-in validator trait in a controller or form request:

   use Rinvex\Support\Traits\Validator;
   
   class MyController extends Controller
   {
       use Validator;
   
       public function store(Request $request)
       {
           $this->validate($request, [
               'name' => 'required|string|max:255',
               'email' => 'required|email',
           ]);
           // Proceed with logic
       }
   }
   

3. Key Entry Points

   • Validator Trait: Rinvex\Support\Traits\Validator (for form validation).
   • Base Controller: Rinvex\Support\Http\Controllers\Controller (includes common methods like respond()).
   • Contracts: Rinvex\Support\Contracts\* (e.g., HasResource, HasApiResource).

Implementation Patterns

1. Validation Workflows

• Form Requests: Extend Rinvex\Support\Http\Requests\FormRequest for reusable validation logic:

  use Rinvex\Support\Http\Requests\FormRequest;
  
  class StoreUserRequest extends FormRequest
  {
      public function rules()
      {
          return [
              'name' => 'required|string',
              'email' => 'required|email|unique:users',
          ];
      }
  }
  

• Dynamic Rules: Use addRules() or mergeRules() in traits to extend validation dynamically:

  $this->addRules(['age' => 'numeric|min:18']);
  

2. Controller Patterns

• Base Controller: Extend Rinvex\Support\Http\Controllers\Controller for shared methods:

  use Rinvex\Support\Http\Controllers\Controller;
  
  class UserController extends Controller
  {
      public function index()
      {
          return $this->respond(['data' => User::all()]);
      }
  }
  

• API Responses: Leverage respond() for consistent JSON/API responses:

  return $this->respond([
      'message' => 'Success',
      'data' => $user,
  ], 200);
  

3. Traits for Reusability

• Resource Handling: Use HasResource trait to auto-generate resource routes:

  use Rinvex\Support\Traits\HasResource;
  
  class UserController extends Controller
  {
      use HasResource;
  
      protected $model = User::class;
  }
  

• API Resource Traits: Extend HasApiResource for API-specific logic:

  use Rinvex\Support\Traits\HasApiResource;
  
  class UserResource extends JsonResource
  {
      use HasApiResource;
  }
  

4. Integration with Rinvex Ecosystem

• Package Agnostic: Works standalone but designed to integrate with other Rinvex packages (e.g., laravel-modules, laravel-activitylog).
• Service Providers: Register custom contracts or bindings via SupportServiceProvider:

  $this->app->bind('custom.helper', function () {
      return new CustomHelper();
  });
  

Gotchas and Tips

Pitfalls

1. Archived Package: No active maintenance; use cautiously in production. Fork or patch if critical bugs arise.
2. Trait Overload: Avoid mixing traits from this package with other validation traits (e.g., Laravel’s native ValidatesRequests) to prevent method conflicts.
3. Config Overrides: Published config may clash with existing Laravel settings (e.g., app.debug). Review config/support.php after publishing.

Debugging Tips

• Validator Errors: Use dd($this->errors()) to inspect validation failures in traits.
• Route Conflicts: If HasResource generates unexpected routes, override getResourceRoutes():

  protected function getResourceRoutes()
  {
      return ['index', 'store', 'show']; // Customize as needed
  }
  

Extension Points

1. Custom Contracts: Implement interfaces like Rinvex\Support\Contracts\HasValidator to extend functionality:

   class MyValidator implements HasValidator
   {
       public function validate(array $data)
       {
           // Custom logic
       }
   }
   

2. Response Modifiers: Override respond() in your controller to customize API responses globally.
3. Validator Extensions: Add custom rules via Validator::extend():

   Validator::extend('custom_rule', function ($attribute, $value, $parameters) {
       return $value === 'allowed';
   });
   

Performance Notes

• Lazy-Loading: Traits like Validator are lightweight; avoid instantiating heavy dependencies in them.
• Caching: If using HasResource, cache route definitions for large applications:

  protected static $cachedRoutes = [];