I. Introduction:
Basically, the Pipeline in Laravel will take the Request and pass it through the global middewares first (for example, CheckForMaintenanceMode, TrimStrings, ValidatePostSize …) then the route middlewares and controller middlewares. Eventually the request will be dispatched to the router for a Illuminate Http Response.
When I learn about Request Lifecycle on the Kernel, I will encounter this code (Refer here ) using Pipeline with the above purpose:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 | protected function sendRequestThroughRouter($request) { $this->app->instance('request', $request); Facade::clearResolvedInstance('request'); $this->bootstrap(); return (new Pipeline($this->app)) ->send($request) ->through($this->app->shouldSkipMiddleware() ? [] : $this->middleware) ->then($this->dispatchToRouter()); } |
Using Pipeline in Laravel you can dynamically pass an object across multiple classes in order, to perform a certain series of tasks (such as passing pipes) and eventually return a result when done. the whole task has been executed. Today we will implement Pipeline in laravel to perform the filter functionality.
II. What is Pipeline Design Pattern?
Pipeline Design Pattern is where data is passed through a series of tasks or stages. Pipeline works like an assembly line where data is processed and then passed on to the next stage. 
Complex processes we can break down into single tasks. Each single task is highly reusable. Break down a large process into smaller tasks that process data, and then move that data to the next step until you get the results you want.
Hic, in theory, we think of a certain product filter function with the purpose that after filtering by category for example 5 products, we want to continue to filter by color based on the previous result ( 5 products) and finally the results we want. Ok here we will apply Pipeline to implement the function of filtering posts by active field and sorting by title.
Step 1: Create a route to return data:
1 2 | Route::get('posts',' <a class="__cf_email__" href="/cdn-cgi/l/email-protection">[email protected]</a> '); |
Step 2: Create Model – Controller – table products:
1 2 | php artisan make:model Post -mr |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 | <?php use IlluminateSupportFacadesSchema; use IlluminateDatabaseSchemaBlueprint; use IlluminateDatabaseMigrationsMigration; class CreatePostsTable extends Migration { /** * Run the migrations. * * @return void */ public function up() { Schema::create('posts', function (Blueprint $table) { $table->bigIncrements('id'); $table->string('title'); $table->string('body'); $table->unsignedSmallInteger('active'); $table->timestamps(); }); } /** * Reverse the migrations. * * @return void */ public function down() { Schema::dropIfExists('posts'); } } |
Step 3: Seed data:
- Factory:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 | <?php /** @var IlluminateDatabaseEloquentFactory $factory */ use AppPost; use FakerGenerator as Faker; $factory->define(Post::class, function (Faker $faker) { return [ 'title' => $faker->sentence(2), 'body' => $faker->sentence(3), 'active' => random_int(0,1), ]; }); |
- Seed data by Tinker:
1 2 3 4 | php artisan tinker factory(AppPost::class,50)->create() exit |
Step 4: Setup Model:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 | <?php namespace App; use IlluminateDatabaseEloquentModel; use IlluminatePipelinePipeline; class Post extends Model { public static function filterPost($request) { $posts = Post::query(); $pipeline = app(Pipeline::class) ->send($posts) ->through([ AppQueryFiltersActive::class, AppQueryFiltersSort::class ]) ->thenReturn(); return $pipeline->get(); } } |
Here we will filter by active post and sort the post by title. Create 2 classes to perform the above task: App QueryFilters Active :: class, App QueryFilters Sort :: class
If you have consulted the Pipeline Laravel class you will see the following 3 methods:
1 2 | $pipeline->send($request); |
You pass the object you want to send through the pipeline.
1 2 | $pipeline->through($middleware); |
Next you pass a series of tasks that will process the request, meaning that the request will go through these tasks one after another.
1 2 3 4 5 | public function thenReturn() { // } |
Finally you get the expected results.
Step 4: Setup Controller:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 | <?php namespace AppHttpControllers; use AppPost; use IlluminateHttpRequest; class PostController extends Controller { public function index(Request $request) { $posts = Post::filterPost($request); return response()->json($posts); } } |
Step 4: Our Custom Class Filter:
- Each class in the through () method must have a “handle” method to perform certain tasks. We will create an interface for these classes.
1 2 3 4 5 6 7 8 9 10 11 | <?php namespace AppQueryFilters; use Closure; interface Pipe { public function handle($request, Closure $next); } |
- And the classes that we use to filter will implement this interface:
App QueryFilters Sort :: class
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 | <?php namespace AppQueryFilters; use Closure; use IlluminateHttpRequest; use Str; class Sort implements Pipe { public function handle($request, Closure $next) { $filterParam = Str::snake(class_basename($this)); if ( ! request()->has($filterParam)){ return $next($request); } $builder = $next($request); return $builder->orderBy('title', request($filterParam)); } } |
App QueryFilters Active :: class
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 | <?php namespace AppQueryFilters; use Closure; use IlluminateHttpRequest; use Str; class Active implements Pipe { public function handle($request, Closure $next) { $filterParam = Str::snake(class_basename($this)); if ( ! request()->has($filterParam)){ return $next($request); } $builder = $next($request); return $builder->where($filterParam, request($filterParam)); } } |
III. Result :
- Reference: Pipelines: https://www.youtube.com/watch?v=7XqEJO-wt7s