Sahrule Laravel Package

Getting Started

Minimal Steps

1. Installation:

   composer require raditzfarhan/sahrule
   

   No additional configuration is required—just publish the package.

2. First Use Case: Validate a base64-encoded image in a request:

   use RaditzFarhan\SahRule\Rules\Base64Image;
   use Illuminate\Http\Request;
   
   public function store(Request $request) {
       $validated = $request->validate([
           'image' => ['required', new Base64Image],
       ]);
   }
   

3. Where to Look First:

   • Namespace: RaditzFarhan\SahRule\Rules for all available rules.
   • README: Check the "Available Rules" table for supported validation types.
   • Source Code: Inspect the Rules directory for customization or extension points.

Implementation Patterns

Usage Patterns

1. Basic Validation: Use rules directly in validate() calls:

   $request->validate([
       'field' => [new CustomRule],
   ]);
   

2. Parameterized Rules: Pass arguments to rules (e.g., allowed MIME types):

   $request->validate([
       'image' => [new Base64Image('png', 'jpeg')],
   ]);
   

3. Reusable Rule Objects: Store rules in a dedicated class for DRY validation:

   class ImageRules {
       public static function base64Image(string ...$types) {
           return new Base64Image(...$types);
       }
   }
   

   Usage:

   $request->validate([
       'image' => [ImageRules::base64Image('png')],
   ]);
   

4. Form Request Integration: Extend FormRequest to centralize validation logic:

   use RaditzFarhan\SahRule\Rules\Base64Image;
   
   public function rules() {
       return [
           'image' => ['required', new Base64Image('gif')],
       ];
   }
   

5. Combining with Laravel Rules: Mix custom rules with built-in Laravel rules:

   $request->validate([
       'image' => ['required', 'max:2048', new Base64Image],
   ]);
   

Workflows

1. API Requests: Validate base64 payloads (e.g., frontend uploads):

   $request->validate([
       'avatar' => [new Base64Image('jpg', 'png')],
   ]);
   

2. CSV/Excel Imports: Validate base64-encoded images in spreadsheet cells:

   $row->validate([
       'profile_pic' => [new Base64Image],
   ]);
   

3. Dynamic Rule Application: Use conditional logic to apply rules:

   $rules = ['required'];
   if ($request->has('allow_images')) {
       $rules[] = new Base64Image;
   }
   $request->validate(['image' => $rules]);
   

Integration Tips

1. Laravel 8+: Use Rule facade for fluent syntax (if rules support it):

   use RaditzFarhan\SahRule\Facades\Rule;
   
   $request->validate([
       'image' => [Rule::base64Image()],
   ]);
   

   (Note: Check if the package provides a facade; if not, create one.)

2. Testing: Mock rules in unit tests:

   $rule = new Base64Image;
   $this->assertTrue($rule->passes('data:image/png;base64,...'));
   

3. Localization: Override error messages in resources/lang/{locale}/validation.php:

   'custom' => [
       'base64_image' => [
           'invalid' => 'The :attribute must be a valid base64-encoded image.',
       ],
   ],
   

Gotchas and Tips

Pitfalls

1. Rule Initialization:

   • Issue: Forgetting to pass required parameters (e.g., allowed types for Base64Image).
   • Fix: Always check the rule’s constructor in the source code for mandatory arguments.
   • Example:

     // Fails if 'png' is not allowed by default
     new Base64Image; // May reject valid PNGs
     

2. Base64 Data Format:

   • Issue: Rules may expect strict base64 format (e.g., data:image/png;base64,...).
   • Fix: Pre-process data or extend the rule to handle variations:

     $data = str_starts_with($request->image, 'data:') ? $request->image : 'data:image/png;base64,' . $request->image;
     

3. Performance:

   • Issue: Complex rules (e.g., image decoding) may slow validation.
   • Fix: Cache rule instances or defer validation until necessary.

4. Namespace Conflicts:

   • Issue: If another package uses RaditzFarhan\SahRule, alias the namespace:

     use RaditzFarhan\SahRule\Rules as SahRules;
     

5. Undocumented Rules:

   • Issue: The package may lack documentation for edge cases.
   • Fix: Inspect the source code (e.g., Rules/Base64Image.php) for behavior details.

Debugging

1. Validation Errors:

   • Check the rule’s message() method for custom error messages:

     $rule = new Base64Image;
     $rule->message(); // Returns default error message
     

   • Override in your validation array:

     $request->validate([
         'image' => [new Base64Image, 'custom_message'],
     ]);
     

2. Logging:

   • Temporarily log rule inputs/outputs:

     $rule = new Base64Image;
     \Log::debug('Rule input:', [$request->image]);
     

3. Testing Edge Cases:

   • Test with malformed base64 (e.g., truncated strings, invalid characters):

     $this->assertFalse((new Base64Image)->passes('invalid_base64_string'));
     

Tips

1. Extending Rules:

   • Create custom rules by extending RaditzFarhan\SahRule\Rules\BaseRule (if available):

     namespace App\Rules;
     use RaditzFarhan\SahRule\Rules\BaseRule;
     
     class CustomImageRule extends BaseRule {
         public function passes($attribute, $value) {
             // Custom logic
         }
     }
     

2. Configuration:

   • Set default allowed types globally via a config file (if supported):

     // config/sahrule.php
     'default_image_types' => ['png', 'jpeg'],
     

   • (Note: Check if the package provides this; otherwise, create a wrapper class.)

3. Laravel 9+:

   • Use Illuminate\Validation\Rule for seamless integration:

     use Illuminate\Validation\Rule;
     use RaditzFarhan\SahRule\Rules\Base64Image;
     
     $rule = Rule::custom(function ($attribute, $value) {
         return (new Base64Image)->passes($attribute, $value);
     });
     

4. Performance Optimization:

   • Pre-compile base64 checks if validating the same field repeatedly:

     $validator = Validator::make($data, ['image' => [new Base64Image]]);
     $validator->validate(); // Reuse validator instance
     

5. Community Contributions:

   • Star the repo and open issues for missing rules (e.g., Base64Video, Base64PDF).
   • Fork and extend the package if needed.