Validator Laravel Package

Getting Started

Minimal Setup

1. Installation

   composer require memio/validator
   

   Ensure memio/validator is registered in config/app.php under providers.

2. Basic Usage Define a Memio Model (assumed to be a custom ORM/ODM layer):

   use Memio\Model;
   
   class User extends Model
   {
       protected $rules = [
           'name' => 'required|string|max:255',
           'email' => 'required|email|unique:users',
           'age' => 'nullable|integer|min:18|max:120',
       ];
   }
   

   Validate an instance:

   $user = new User(['name' => 'John', 'email' => 'invalid-email']);
   $validator = app('validator')->make($user->toArray(), $user->rules);
   if ($validator->fails()) {
       dd($validator->errors());
   }
   

3. First Use Case Use in a controller to validate incoming requests:

   use Memio\Validator\Facades\Validator;
   
   public function store(Request $request)
   {
       $validated = Validator::make($request->all(), User::rules)->validate();
       $user = User::create($validated);
       return response()->json($user);
   }
   

Implementation Patterns

Model-Based Validation

• Rule Inheritance: Extend models to reuse validation logic:

  class Admin extends User
  {
      protected $rules = [
          'role' => 'required|in:admin,superadmin',
      ];
  }
  

• Dynamic Rules: Use closures for context-aware validation:

  protected $rules = [
      'password' => function ($value, $attribute, $fail) {
          if (strlen($value) < 8 && auth()->check()) {
              $fail('Password must be at least 8 characters.');
          }
      },
  ];
  

Integration with Laravel Ecosystem

• Form Requests: Combine with Laravel’s FormRequest for API/HTTP validation:

  use Memio\Validator\Rules\MemioRule;
  
  public function rules()
  {
      return array_merge(parent::rules(), [
          'custom_field' => [new MemioRule('required_if', 'active', true)],
      ]);
  }
  

• Service Layer: Centralize validation in a service:

  class UserService
  {
      public function validateUser(array $data)
      {
          return Validator::make($data, User::rules)->validate();
      }
  }
  

Custom Rules

• Extend Memio\Validator\Rules\Rule for domain-specific logic:

  namespace App\Rules;
  
  use Memio\Validator\Rules\Rule;
  
  class UniqueMemioId extends Rule
  {
      public function passes($attribute, $value)
      {
          return Model::where('id', $value)->doesntExist();
      }
  }
  

  Use in model rules:

  protected $rules = [
      'id' => 'nullable|unique_memio_id',
  ];
  

Gotchas and Tips

Pitfalls

• Rule Caching: Memio’s rules are evaluated per-instance. Avoid caching $rules in static properties unless intentional.
• Model Initialization: Rules are only loaded if the model is instantiated. Use app('memio.validator')->make($data, Model::rules) for standalone validation.
• Laravel Conflict: If using Laravel’s built-in validator, alias memio/validator to avoid collisions:

  'aliases' => [
      'MemioValidator' => Memio\Validator\Facades\Validator::class,
  ],
  

Debugging

• Silent Failures: Use ->validate() (throws ValidationException) or ->validateWithBag() for custom error bags.
• Rule Debugging: Dump rules dynamically:

  dd(app('memio.validator')->extend('custom_rule', function ($attribute, $value, $parameters) {
      // Debug logic here
  }));
  

Extension Points

• Custom Translations: Override error messages in resources/lang/en/validation.php with Memio-specific keys (e.g., memio_unique).
• Presets: Define reusable rule sets in a trait:

  trait HasCommonRules
  {
      public function commonRules()
      {
          return [
              'slug' => 'required|slug|unique:posts,slug',
          ];
      }
  }
  

  Merge in model:

  protected $rules = $this->commonRules();
  

Performance

• Lazy Loading: Rules are parsed on first use. For bulk validation, preload rules:

  $rules = User::rules(); // Force load
  Validator::make($data, $rules)->validate();