In the realm of web development, efficiently managing and querying metadata is a recurring challenge, especially when dealing with a diverse set of data across various clients. This article delves into creating a flexible and efficient metadata filter in Laravel 10.x, without the reliance on extra packages.

The Scenario

Consider an application structure where a Client has many Profiles, and each Profile has many ProfileRows, akin to:

$ProfileRow = [
    'name' => 'Phone',
    'content' => '+458988898',
];

This simple yet flexible metadata structure caters well to varying client requirements. However, efficiently filtering through this metadata, based on different operators, names, and content of ProfileRows, posed a significant challenge.

The Initial Request

The base request looked something like this:

$client_id = 1;
$client = Client::find($client_id);
$profiles = $client->profiles()->with('profile_rows')->get();

The Solution

Creating Enums for Operators

A flexible set of operators is crucial for a robust filter. Enums in PHP (introduced in PHP 8.1) offer a type-safe way to define such sets. Here’s how you can define an Enum for your operators:

namespace App\Enums;

enum FilterOperator: string {
    case Equals = 'equals';
    case Contains = 'contains';
    case GreaterThan = 'greater_than';
    case LessThan = 'less_than';
    case GreaterThanOrEqual = 'greater_than_or_equal';
    case LessThanOrEqual = 'less_than_or_equal';
}

Setting up a Scope in the Model

Laravel’s eloquent scopes are a powerful feature that allows you to encapsulate common query logic. By adding a scope to the Profile model, you can streamline the filtering process:

namespace App\Models;

use App\Enums\FilterOperator;
use Illuminate\Database\Eloquent\Model;

class Profile extends Model {
    public function scopeWithProfileRowsFilters($query, array $filters) {
        foreach ($filters as $filter) {
            if (!isset($filter['name']) || !isset($filter['operator']) || !isset($filter['content'])) {
                throw new \InvalidArgumentException('Invalid filter');
            }
            $operator = FilterOperator::tryFrom($filter['operator']);
            if (!$operator) {
                throw new \InvalidArgumentException('Invalid operator');
            }
            $query->whereHas('profile_rows', function ($query) use ($filter, $operator) {
                $query->where('name', $filter['name']);
                match ($operator) {
                    FilterOperator::Equals => $query->where('content', $filter['content']),
                    FilterOperator::Contains => $query->where('content', 'like', '%' . $filter['content'] . '%'),
                    FilterOperator::GreaterThan => $query->where('content', '>', $filter['content']),
                    FilterOperator::LessThan => $query->where('content', '<', $filter['content']),
                    FilterOperator::GreaterThanOrEqual => $query->where('content', '>=', $filter['content']),
                    FilterOperator::LessThanOrEqual => $query->where('content', '<=', $filter['content']),
                };
            });
        }
        return $query;
    }
}

Executing the Query

With the above setup, filtering profiles based on ProfileRows becomes straightforward:

$filters = [
 [
 'name' => 'Phone',
 'operator' => 'contains',
 'content' => '+45',
 ],
 [
 'name' => 'firstname',
 'operator' => 'equals',
 'content' => 'Kim',
 ],
];

$profiles = Client::find(1)->profiles()->withProfileRowsFilters($filters)->get();

Conclusion

This approach to metadata filtering in Laravel leverages the framework’s built-in features, like Eloquent scopes, and the robustness of PHP Enums, to create a flexible and reusable solution without additional dependencies. While the focus here was on a specific use case, the principles can be applied to a wide range of scenarios, making your Laravel applications more versatile and maintainable.