Laravel Middlewarize Laravel Package

Getting Started

Minimal Setup

1. Installation:

   composer require imanghafoori/laravel-middlewarize
   

   Publish the config (optional):

   php artisan vendor:publish --provider="Imanghafoori\Middlewarize\MiddlewarizeServiceProvider"
   

2. First Use Case: Apply middleware to a service method (e.g., UserService::create()):

   use Imanghafoori\Middlewarize\Facades\Middlewarize;
   
   Middlewarize::middleware(['auth', 'validate.user'])->on('App\Services\UserService@create');
   

3. Where to Look First:

   • Facade: Imanghafoori\Middlewarize\Facades\Middlewarize (for fluent syntax).
   • Config: config/middlewarize.php (for global defaults).
   • Middleware Registration: app/Providers/MiddlewarizeServiceProvider.php (for bootstrapping).

Implementation Patterns

Core Workflows

1. Method-Level Middleware:

   // Apply to a single method
   Middlewarize::middleware(['throttle:5'])->on('App\Services\OrderService@placeOrder');
   
   // Apply to all methods in a class
   Middlewarize::middleware(['log'])->on('App\Services\*');
   

2. Dynamic Middleware: Use closures for conditional logic:

   Middlewarize::middleware(function ($request, $next) {
       if ($request->user()->isAdmin()) {
           return $next($request);
       }
       abort(403);
   })->on('App\Services\AdminService@*');
   

3. Integration with Laravel’s HTTP Middleware: Reuse existing middleware classes:

   Middlewarize::middleware(\App\Http\Middleware\CheckForMaintenance::class)
       ->on('App\Services\DeploymentService@deploy');
   

4. Service Container Binding: Register middleware for container-bound services:

   $this->app->bind('App\Services\PaymentService', function ($app) {
       $service = new PaymentService();
       Middlewarize::middleware(['validate.payment'])->on($service, 'charge');
       return $service;
   });
   

5. Grouping Middleware: Define reusable middleware groups in config/middlewarize.php:

   'groups' => [
       'api' => ['throttle:60', 'auth:api'],
       'admin' => ['auth', 'admin'],
   ],
   

   Then apply groups:

   Middlewarize::middleware('api')->on('App\Services\ApiService@*');
   

6. Exception Handling: Catch middleware exceptions globally:

   Middlewarize::catch(function ($request, $exception) {
       \Log::error("Middleware failed: {$exception->getMessage()}");
       abort(500);
   });
   

Integration Tips

• Testing: Use Middlewarize::fake() to bypass middleware in tests:

  public function test_method_with_middleware()
  {
      Middlewarize::fake();
      $result = $this->service->create(...);
      // Assertions...
  }
  

• Performance: Cache middleware registrations in boot() of a service provider:

  public function boot()
  {
      Middlewarize::cacheRegistrations();
  }
  

• Laravel Events: Trigger middleware on events (via EventServiceProvider):

  Middlewarize::middleware(['validate'])->on('event:order.created');
  

Gotchas and Tips

Pitfalls

1. Middleware Order:

   • Middleware runs in registration order (last registered runs last).
   • Use ->before() or ->after() to reorder:

     Middlewarize::middleware('auth')->before('validate')->on('App\Services\UserService@update');
     

2. Circular Dependencies: Avoid applying middleware to methods that are called within the same middleware chain (risk of infinite loops).

3. Dynamic Method Names: Wildcards (*) match all methods, but method name collisions can occur if multiple registrations target the same method. Explicitly specify methods when needed:

   Middlewarize::middleware('auth')->on('App\Services\UserService@create', 'App\Services\UserService@update');
   

4. Middleware Resolution:

   • If a middleware isn’t found, the package silently skips it (no error thrown). Use ->strict() to enforce resolution:

     Middlewarize::middleware('nonexistent')->strict()->on('App\Services\*');
     

5. Request Context: Middleware receives the current Laravel request ($request). For non-HTTP contexts (e.g., commands, jobs), pass a Request instance manually:

   $request = Request::create('/dummy', 'GET');
   Middlewarize::run('App\Services\JobService@process', $request);
   

Debugging

1. Log Middleware Execution: Enable debug mode in config/middlewarize.php:

   'debug' => env('MIDDLEWARE_DEBUG', false),
   

   Logs will appear in storage/logs/laravel.log.

2. Inspect Registrations: Dump all registered middleware:

   dd(Middlewarize::getRegistrations());
   

3. Middleware Dumping: Use Artisan to list middleware for a specific method:

   php artisan middlewarize:list App\Services\UserService@create
   

Extension Points

1. Custom Middleware Types: Extend the package to support non-Laravel middleware (e.g., Symfony middleware):

   Middlewarize::extend('symfony', function ($middleware) {
       return new SymfonyMiddlewareAdapter($middleware);
   });
   

2. Middleware Events: Listen for middleware execution events:

   Middlewarize::listen('before', function ($middleware, $method, $request) {
       // Logic before middleware runs
   });
   

3. Custom Matchers: Override method matching logic (e.g., regex patterns):

   Middlewarize::matcher(function ($method, $pattern) {
       return preg_match($pattern, $method);
   });
   

4. Global Middleware: Apply middleware to all methods in a namespace:

   Middlewarize::middleware('log')->on('App\Services\*');
   

5. Conditional Registration: Dynamically register middleware based on environment or config:

   if (config('app.debug')) {
       Middlewarize::middleware('log')->on('App\Services\*');
   }