Hi guys, as I have written this functionality a few times at this point, and I have been asked how to do it a couple of times, too. That is Laravel searching and filtering, I am going to develop a simple composer package which I can use to allow users to search and filter Laravel (Eloquent) Models using PHP traits which can be used on Laravel controllers.
Assumptions
I am going to work on the assumption that you are comfortable with basics.
I shall also assume you’re fairly comfortable with the Illuminate HTTP Request object, a Controller, and Eloquent Model.
Concept
So the first thing we want to tackle, as a concept, is that the best way, in my experience, is to start with a query, and then modify it as required. This allows us to optionally do almost anything, but equally allows us to do nothing, and simply return an unfiltered set if we want to.
This point would be true outside of Eloquent too, even if working with vanilla SQL.
Starting Off
To start with you want something like this within your Controller.
public function index(Request $request)
{
// Of course you can change this if you don't want to select everything
$query = YourModel::select('*');
}
Now we have the $query object which we can work with as and where we want to.
Filtering Records
Excluding deleted/is deleted, as we’ll cover that later on.
Let’s say you now want to filter results on author_id just to keep things simple.
if(!empty($request->author)){
$query->where('author_id', '=', $request->author);
}
Of course take into account everything here, you may need to do sanitisation or validation or anything else in there.
Multiple Filters, Save Lines
If you have many fields on which you wish to do this I usually find something like this is better
$fields = ['author_id', 'category_id'];
foreach($fields as $field){
if(!empty($request->$field)){
$query->where($field, '=', $request->$field);
}
}
That example assumes the exposure of your field names, you could always use an associative array so you could do “author” maps to “author_id” and so on, if you were so inclined.
Fluffy Search
Now you might want to do a fluffy search, taking the assumption of posts with content and an author name, and a category name (stored within the model) you could do something like this
if(!empty($request->search)){
$searchFields = ['title','content','author_name','category_name'];
$query->where(function($query) use($request, $searchFields){
$searchWildcard = '%' . $request->search . '%';
foreach($searchFields as $field){
$query->orWhere($field, 'LIKE', $searchWildcard);
}
})
}
Handling Trash
You probably want something which allows you to see soft deleted models, if you’re using them. I do something like this
if($request->trash == true){
// Retrieve soft deleted models only, you can only do this if you're using soft deletion on this model
$query->onlyTrashed();
}
Ordering and Limiting
Now to handle ordering and pagination – which Eloquent beautifully does for us, all we need to do is let the user modify it if they want to.
// Set the query ordering
$query->order($request->orderBy ?? 'updated_at', $request->order ?? 'DESC');
$perPage = $request->per_page ?? 25;
// It is a good idea to make sure we cap this
if($perPage > $maximumPerPage){
$perPage = $maximumPerPage;
}
// Final part - get the results
$results = $query->paginate($perPage);
// You will now need to do something with your results, and return some kind of Response - this could be a JSON response or adding the results to the data returned to the view, depending on your context
There’s an assumption here that our default order is updated at, last updated first, and that if not specified, we want to return 25 pages.
Of course you can store this information wherever you want.
In Summary, and Further Reading
Rather than creating a really complicated set of rules to handle all the things you may need from your API calls, start with a query, and then optionally modify that query.
