DEV Community: Jahid Hassan Shovon

How I Simplified My Laravel Filters Using the Pipeline Pattern (With Real Examples)

Jahid Hassan Shovon — Fri, 24 Oct 2025 18:07:49 +0000

Today I learned a new topic in Laravel — Laravel Pipeline.
Let me first explain the problem I faced. In each of my repository files, I had to perform filtering in the index method. I noticed that in almost every filter, I was filtering by things like name, email, status, word, or similar fields — only the data source was different. I was doing the filtering like this:

Product::when(isset($request->status), function ($query) use ($request) {
    $query->where('status', $request->status);
})
->when(isset($request->search), function ($query) use ($request) {
    $query->where('name', 'like', '%' . $request->search . '%');
})
->when(isset($request->verify_status), function ($query) use ($request) {
    $query->where('verify_status', $request->verify_status);
})->get();

Note: Similarly filter apply for more columns

The thing to notice here is that my data sources are different, but the rest of the processes are the same. After realizing this, I started looking for a way to optimize it and found an amazing concept called the Pipeline Pattern. By using this approach, I now need to write much less code in each index method, and the code has become more reusable.
Now I’ll show the state of the code after adding the Pipeline Pattern.

First step we need to create filter classes for each filter option.

Create a Filters folder under app directory. Remember all filter option file create here.
The filter classes will be created in the project/app/Filters directory.

Filter by Name -

project/app/Filters/ByName.php

<?php
namespace App\Filters;
use Illuminate\Database\Eloquent\Builder;
use Illuminate\Http\Request;

class ByName
{
    public function __construct(
        protected Request $request
    ){}
    public function handle(Builder $builder, \Closure $next)
    {
        return $next($builder)->when(
            $this->request->has('name'), fn($query) => $query->where('name', 'like', '%'.$this->request->name.'%')
        );
    }
}

Filter by Status -

project/app/Filters/ByStatus.php

<?php
namespace App\Filters;
use Illuminate\Database\Eloquent\Builder;
use Illuminate\Http\Request;
class ByStatus
{
    public function __construct(
        protected Request $request
    ){}
    public function handle(Builder $builder, \Closure $next)
    {
        return $next($builder)->when(
            $this->request->has('status'), fn($query) => $query->where('status', $this->request->status)
        );
    }
}

Filter by Address -

project/app/Filters/ByAddress.php

<?php
namespace App\Filters;
use Illuminate\Database\Eloquent\Builder;
use Illuminate\Http\Request;
class ByAddress
{
    public function __construct(
        protected Request $request
    ){}
    public function handle(Builder $builder, \Closure $next)
    {
        return $next($builder)->when(
            $this->request->has('address'), fn($query) => $query->where('address', 'like', '%'.$this->request->address.'%')
        );
    }
}

Second Step: How to use pipeline in controller or repositories file


<?php
namespace App\Repositories;
use Illuminate\Support\Facades\Pipeline;
use App\Filters\ByName;
use App\Filters\ByStatus;
use App\Models\Product;

class ProductRepository
{
    public function index($data)
    {
        $pipeline = [
            ByName::class,
            ByStatus::class,
            ByAddress::class,
        ];

        $product = Product::query();

        return Pipeline::send($product)
            ->through($pipeline)
            ->thenReturn()
            ->paginate($data['limit'] ?? 50);
    }
}

We use send($product) method to inject the initial data. In this case, the new created product.
The through($pipeline) method to provide the operations we want to execute with the input we are giving.
Finally, the then() runs the pipeline and returns the result.

Now I can reuse the filter options in other places as well. I just need to add the filter classes to the pipeline, and that’s it. The code has also become much cleaner. You should try it too — you’ll love it.

Now we will learn more about the pipeline pattern.

What is the Pipeline Design Pattern?
The Pipeline Design Pattern is a behavioral design pattern that passes data through a sequence of stages (called pipes). Each stage modifies or processes the data and then passes it along to the next one.

You can visualize it like this:

Input → [Pipe 1] → [Pipe 2] → [Pipe 3] → Output

Why Use the Pipeline Pattern?

Clean Code: It removes nested logic and long “if/else” chains, leading to more readable code.
Separation of Concerns: Each pipe does one thing (Single Responsibility Principle).
Reusability: Each pipe is independent and can be reused in different pipelines or projects.
Maintainability: Adding or removing a step in the process doesn’t break other parts — you just plug or unplug a pipe.
Testability: Each pipe can be tested individually, making unit testing easier.

How It Works

In Laravel, the Pipeline class (found in Illuminate\Pipeline\Pipeline) makes it easy to send data through a pipeline.

A pipeline has:

Data/Input – the initial object or request to process
Pipes – classes or closures that process the data
Destination/Closure – the final output step

Real-world Use Cases

Data transformation before saving
Building flexible API request handlers
Processing uploaded files
Business rule validation chains
Complex workflow processing (e.g., order processing pipeline)
Custom request handling before controller logic

More resources

How to Use Multiple GitHub Accounts on One Computer (Step-by-Step Guide)

Jahid Hassan Shovon — Thu, 16 Oct 2025 20:21:02 +0000

Table of content

Introduction
Set up SSH keys for each GitHub account
Add the SSH keys to the SSH agent
Add each public SSH key to the corresponding GitHub account
Configure SSH for multiple accounts
Clone repositories using specific SSH config
Configure Git user for each repository

Introduction

As developers, we often work across multiple projects, some for our organization, our clients project, and maybe a few personal ones too. Each of these may require a different GitHub account or GitLab or similar kind of tools, which can lead to authentication conflicts, commit misattributions, and deployment issues if not managed properly. To ensure a smooth workflow, it’s essential to configure your computer so that it can handle multiple GitHub accounts seamlessly. Today we learned how to manage multiple github accounts from one computer. If you know this process, you can ignore this post.

To make this easier to understand, let’s consider a simple scenario. I contribute to my company’s projects using my office account (office@gmail.com), handle client projects with my client account (client@gmail.com), and manage personal repositories through my personal account (personal@gmail.com).

Make a directory .ssh in c/Users/jahid directory (if no exist .ssh directory). Open gitbash terminal under .ssh directory.

Set up SSH keys for each github account

Every account needs to generate public and private ssh key.

Personal account

ssh-keygen -t rsa -b 4096 -C "personal@gmail.com" -f ~/.ssh/id_rsa_personal

Office account

ssh-keygen -t rsa -b 4096 -C "office@gmail.com" -f ~/.ssh/id_rsa_office

Client account

ssh-keygen -t rsa -b 4096 -C "client@gmail.com" -f ~/.ssh/id_rsa_client

Note: After running this command, you need to enter a password and confirm the password. In future, when you push or clone any repository, you need to enter this password.

Add the SSH keys to the SSH agent

Start the SSH agent in the background =>

eval "$(ssh-agent -s)"

When you run this command in Git Bash, it will output something like: Agent pid 1234

Add your SSH private key to the agent:

ssh-add ~/.ssh/id_rsa_personal

ssh-add ~/.ssh/id_rsa_office

ssh-add ~/.ssh/id_rsa_client

If the key is added successfully, you should see some file like =>
bash /c/Users/jahid/.ssh/id_rsa_personal

Verify the key is added =>

ssh-add -l

When you run this command in Git Bash, it will output something like:

4096 SHA256:xxxxxxxxxxxxxx /c/Users/jahid/.ssh/id_rsa_personal (your_email@example.com)

Add each public SSH key to the corresponding GitHub account

Here I will say this process only for personal accounts. Follow this process for every github account.

Find your public SSH key

C:\Users\jahid\.ssh\id_rsa_personal.pub (on Windows)

Copy the public key to your clipboard

cat id_rsa_personal.pub

Note: This will display the contents of the public key. Copy everything shown in the output (starting with ssh-rsa and ending with your email).

Add a new SSH key in you responsible github account

Go to your GitHub account, navigate to Settings > SSH and GPG keys > New SSH key > Enter Title, Key type should be authentication key, Enter Key (Which you was copy form previous step) > Save

Note: Follow this process for every github account

Configure SSH for multiple accounts

Edit the sh c/Users/userName/.ssh/config

Personal GitHub Account

Host github.com-personal
  HostName github.com
  User git
  IdentityFile ~/.ssh/id_rsa_personal

Office GitHub Account

Host github.com-office
  HostName github.com
  User git
  IdentityFile ~/.ssh/id_rsa_office

Client GitHub Account

Host github.com-client
  HostName github.com
  User git
  IdentityFile ~/.ssh/id_rsa_client

Note: HostName should be which host used to store your repository. Also be careful about IdentityFile.

Clone repositories using specific SSH config

When you clone the repositories, make sure to use the corresponding Host as defined in your SSH config.

Format

git clone [Host]:[GithubUserName]/[repository].git

Example

git clone git@github.com-personal:username/project.git

git clone git@github.com-office:user/git-repository-for-office.git

git clone git@github.com-client:user/git-repository-for-client.git

Configure Git user for each repository

You need to configure for every cloned project

For example

You will configure your personal accounts clone project. Go to your project file, open a terminal and enter those command

git config user.name "personal"

git config user.email "personal@gmail.com"

N.B.: If anything isn’t clear or you have any suggestions, please feel free to share them in the comments — I’ll be glad to respond. If you notice any mistakes, I truly appreciate your feedback. Thank you for taking the time to read this post. Wishing you all happy and productive coding! 💻✨

Originally published on Hashnode.