DEV Community: Abdalrhman Emad Saad

Stop Writing Filter Logic in Controllers — Meet Filterable for Laravel

Abdalrhman Emad Saad — Wed, 11 Mar 2026 19:59:18 +0000

The Complete Guide to Filterable: Clean, Scalable Eloquent Filtering for Laravel

If you've ever built a Laravel API with search and filtering, you've probably written something like this:

$query = Post::query();

if ($request->status) {
    $query->where('status', $request->status);
}

if ($request->title) {
    $query->where('title', 'like', "%{$request->title}%");
}

if ($request->created_after) {
    $query->where('created_at', '>=', $request->created_after);
}

// ...10 more conditions

It works. But as the project grows, this logic spreads across controllers, gets duplicated, and becomes nearly impossible to test in isolation.

Filterable solves this by moving all filtering logic into dedicated, testable filter classes — and giving you four different engines to structure that logic however fits your use case.

Installation

composer require kettasoft/filterable

php artisan vendor:publish --provider="Kettasoft\Filterable\Providers\FilterableServiceProvider" --tag="config"

Your First Filter

Generate a filter class using the CLI:

php artisan filterable:make-filter PostFilter --filters=title,status

This creates App\Http\Filters\PostFilter. Open it and define your filter methods:

namespace App\Http\Filters;

use Kettasoft\Filterable\Filterable;
use Kettasoft\Filterable\Support\Payload;

class PostFilter extends Filterable
{
    protected $filters = ['status', 'title'];

    protected function title(Payload $payload)
    {
        return $this->builder->where('title', 'like', $payload->asLike('both'));
    }

    protected function status(Payload $payload)
    {
        return $this->builder->where('status', $payload->value);
    }
}

Apply it in your controller:

public function index()
{
    return Post::filter(PostFilter::class)->paginate();
}

Now GET /posts?status=active&title=laravel automatically triggers the right methods. No if-statements, no manual $request->has() checks.

Binding the Filter to Your Model

If you always use the same filter class for a model, you can bind it directly:

use Kettasoft\Filterable\Traits\HasFilterable;

class Post extends Model
{
    use HasFilterable;

    protected $filterable = PostFilter::class;
}

Now your controller becomes a single line:

return Post::filter()->paginate();

Choosing an Engine

This is where Filterable stands apart from other filtering packages. Instead of forcing one approach, it ships with four engines. You pick the one that matches how your frontend sends data.

Engine	Best For	Example
Invokable	Custom logic per field	`?status=active&title=laravel`
Ruleset	Operator-based API queries	`?filter[title][like]=laravel`
Expression	Ruleset + nested relations	`?filter[author.name][like]=ahmed`
Tree	Complex AND/OR JSON logic	`{ "and": [...] }`

Let's go through each one.

1. Invokable Engine

The default engine. Each request key maps to a method in your filter class. Clean, explicit, and easy to understand.

class PostFilter extends Filterable
{
    protected $filters = ['status', 'title', 'created_at'];

    protected function status(Payload $payload)
    {
        return $this->builder->where('status', $payload->value);
    }

    protected function title(Payload $payload)
    {
        return $this->builder->where('title', 'like', $payload->asLike('both'));
    }

    protected function created_at(Payload $payload)
    {
        return $this->builder->whereDate('created_at', '>=', $payload->value);
    }
}

You can also use PHP 8 Annotations to add behavior per method without writing extra code:

use Kettasoft\Filterable\Annotations\Cast;
use Kettasoft\Filterable\Annotations\SkipIf;
use Kettasoft\Filterable\Annotations\Between;

class PostFilter extends Filterable
{
    protected $filters = ['status', 'created_at'];

    #[Cast('integer')]
    #[DefaultValue(1)]
    protected function status(Payload $payload)
    {
        return $this->builder->where('status', $payload->value);
    }

    #[SkipIf('auth()->guest()')]
    #[Between(min: '2020-01-01', max: 'now')]
    protected function created_at(Payload $payload)
    {
        return $this->builder->whereDate('created_at', $payload->value);
    }
}

Available annotations: #[Authorize] #[SkipIf] #[Cast] #[Sanitize] #[Trim] #[DefaultValue] #[MapValue] #[Explode] #[Required] #[In] #[Between] #[Regex] #[Scope]

2. Ruleset Engine

Ideal for REST APIs where the frontend sends structured filter parameters with explicit operators.

GET /posts?filter[status]=published
GET /posts?filter[title][like]=%laravel%
GET /posts?filter[views][gte]=100
GET /posts?filter[id][in][]=1&filter[id][in][]=2
GET /posts?filter[price][between][]=10&filter[price][between][]=50

Define your filter class with allowed fields and operators:

class PostFilter extends Filterable
{
    protected $allowedFields = ['status', 'title', 'views', 'created_at'];

    protected $allowedOperators = ['eq', 'like', 'gte', 'lte', 'in', 'between'];
}

No methods needed — the engine handles the query building automatically.

Supported operators: eq neq gt gte lt lte like nlike in nin between null notnull

3. Expression Engine

Everything the Ruleset engine does, plus the ability to filter through nested Eloquent relationships using dot notation.

GET /posts?filter[author.profile.name][like]=ahmed
GET /posts?filter[status]=active&filter[category.name]=laravel

use Kettasoft\Filterable\Facades\Filterable;

Filterable::create()
    ->useEngine('expression')
    ->allowedFields(['status', 'title'])
    ->allowRelations([
        'author.profile' => ['name', 'bio']
    ])
    ->filter(Post::query());

The engine automatically resolves the relation path and applies whereHas queries — no manual join logic needed.

4. Tree Engine

For advanced use cases where the frontend needs to build complex AND/OR logic — think filter builders in admin panels or reporting tools.

The request sends a nested JSON tree:

{
  "filter": {
    "and": [
      { "field": "status", "operator": "eq", "value": "active" },
      {
        "or": [
          { "field": "views", "operator": "gte", "value": 1000 },
          { "field": "featured", "operator": "eq", "value": true }
        ]
      }
    ]
  }
}

The engine recursively translates this into Eloquent where / orWhere groups. It also supports depth limiting to protect against overly complex queries:

// config/filterable.php
'tree' => [
    'depth_limit' => 3,
    'normalize_keys' => true,
]

Validation & Sanitization

Input handling lives inside the filter class, not scattered across controllers or form requests.

Validation uses Laravel's native rules format:

class PostFilter extends Filterable
{
    protected $rules = [
        'status' => ['required', 'string', 'in:active,pending,archived'],
        'title'  => ['sometimes', 'string', 'max:100'],
    ];
}

If validation fails, a ValidationException is thrown automatically.

Sanitization runs before validation, via dedicated sanitizer classes:

class PostFilter extends Filterable
{
    protected $sanitizers = [
        TrimSanitizer::class,           // global — runs on all fields
        'title' => [
            StripTagsSanitizer::class,
            CapitalizeSanitizer::class,
        ],
    ];
}

A sanitizer implements the Sanitizable interface:

class TrimSanitizer implements Sanitizable
{
    public function sanitize(mixed $value): mixed
    {
        return is_string($value) ? trim($value) : $value;
    }
}

Execution order: sanitize → validate → filter.

Authorization

Protect a filter class based on roles or permissions by defining an authorize() method:

class AdminFilter extends Filterable
{
    public function authorize(): bool
    {
        return auth()->user()?->isAdmin() ?? false;
    }
}

If authorize() returns false, a FilterAuthorizationException is thrown before any filtering runs. Per-method authorization is also available via the #[Authorize] annotation in the Invokable engine.

Sorting

Define which fields are sortable via $sortable:

class PostFilter extends Filterable
{
    protected $sortable = ['created_at', 'views', 'title'];
}

GET /posts?sort=-created_at   # descending
GET /posts?sort=views         # ascending

Caching

Filterable has a full caching system built into the filter pipeline.

// Cache for 1 hour
Post::filter()->cache(3600)->get();

// User-scoped — each user gets their own cache entry
Post::filter()->cache(1800)->scopeByUser()->get();

// Tagged cache — easy to invalidate by group
Post::filter()->cache(3600)->cacheTags(['posts', 'content'])->get();
Post::flushCacheByTagsStatic(['posts']);

// Conditional caching
Post::filter()->cacheWhen(!auth()->user()->isAdmin(), 3600)->get();

// Reusable cache profiles defined in config
Report::filter()->cacheProfile('heavy_reports')->get();

Enable auto-invalidation in config/filterable.php and cache is cleared automatically when a model is created, updated, or deleted:

'auto_invalidate' => [
    'enabled' => true,
    'models' => [
        \App\Models\Post::class => ['posts', 'content'],
    ],
],

CLI Reference

# Create a new filter class
php artisan filterable:make-filter PostFilter --filters=title,status

# Discover and register all filter classes in your app
php artisan filterable:discover

# List all registered filters
php artisan filterable:list

# Test a filter with a sample payload
php artisan filterable:test PostFilter --payload='{"status":"active"}'

# Inspect a filter class (engine, fields, rules, sanitizers...)
php artisan filterable:inspect PostFilter

Wrapping Up

Filterable gives you a structured, testable way to handle Eloquent filtering without cluttering your controllers. Whether you need simple key-value filters or complex nested AND/OR trees, there's an engine for it — and they all share the same validation, sanitization, authorization, caching, and sorting infrastructure.

Links:

📦 GitHub
📚 Documentation
🚀 Packagist

Built by Kettasoft. MIT Licensed.

Stop Writing Messy Queries in Laravel — Meet kettasoft/filterable 🚀

Abdalrhman Emad Saad — Mon, 01 Sep 2025 11:51:45 +0000

🚀 Supercharge Your Laravel Queries with kettasoft/filterable

When building Laravel applications, one of the most common pain points is handling dynamic filtering from requests.

If you've ever written controllers like this:

public function index(Request $request)
{
    $query = Post::query();

    if ($request->has('status')) {
        $query->where('status', $request->status);
    }

    if ($request->has('author_id')) {
        $query->where('author_id', $request->author_id);
    }

    if ($request->has('search')) {
        $query->where('title', 'like', '%' . $request->search . '%');
    }

    return $query->paginate();
}

…you know how quickly it becomes messy, repetitive, and hard to maintain. 😵

✨ Meet `kettasoft/filterable`

This package makes request-based filtering simple, reusable, and powerful.

Instead of manually checking request inputs, you can write clean filter classes and attach them to your models.

⚡ Before vs After

❌ Without `filterable`:

$posts = Post::query();

if (request('status')) {
    $posts->where('status', request('status'));
}

if (request('author_id')) {
    $posts->where('author_id', request('author_id'));
}

$posts = $posts->paginate();

✅ With `filterable`:

$posts = Post::filter(new PostFilter)->paginate();

Your filters are now reusable, testable, and clean.

🛠 Example Filter

use Kettasoft\Filterable\Filter;

class PostFilter extends Filter
{
    public function status($value)
    {
        $this->query->where('status', $value);
    }

    public function author_id($value)
    {
        $this->query->where('author_id', $value);
    }

    public function search($value)
    {
        $this->query->where('title', 'like', "%{$value}%");
    }
}

Now, calling /posts?status=published&search=laravel automatically applies the filters! 🎉

🔧 Sorting Support

It even supports sorting with customization:

Filterable::addSorting(PostFilter::class, function (Sortable $sort) {
    $sort->allow(['id', 'title', 'created_at'])
         ->default('created_at', 'desc');
});

Request:

/posts?sort=-title

Query generated:

select * from posts order by title desc

🌍 Why use `kettasoft/filterable`?

✅ Clean & maintainable queries
✅ Reusable filter classes
✅ Global & local filters
✅ Sorting with direction maps (-field = desc)
✅ Support for multi-sort

📦 Installation

composer require kettasoft/filterable

📝 Final Thoughts

If you want to keep your controllers clean and make your queries more expressive, powerful, and reusable, give kettasoft/filterable a try.

It saves time, improves maintainability, and makes your codebase a lot more fun to work with. 🚀

Scaffolding

Abdalrhman Emad Saad — Thu, 26 Sep 2024 20:58:26 +0000

Scaffolding is a powerful and flexible Laravel-based web application framework that follows the HMVC (Hierarchical Model-View-Controller) architecture. It provides a strong structure for building robust and scalable web applications.

Main Function Points

Utilizes the Laravel framework as the foundation
Follows the HMVC (Hierarchical Model-View-Controller) architecture
Supports multiple databases (MySQL, PostgreSQL, SQLite)
Includes pre-built modules and features for rapid development
Provides a user-friendly installer for easy setup
Allows customization of dashboard colors and other settings
Includes sample data seeding for quick prototyping

Technology Stack

PHP
Laravel Framework
HMVC (Hierarchical Model-View-Controller) Architecture
MySQL, PostgreSQL, or SQLite Database
HTML, CSS (SCSS), JavaScript

License

Scaffolding is an open-source project licensed under the MIT License.

Explore

Smart student

Abdalrhman Emad Saad — Fri, 23 Aug 2024 01:13:46 +0000

Software Requirements Specification (SRS) for DRUGHUB

Abdalrhman Emad Saad — Mon, 19 Aug 2024 21:22:24 +0000

1. Introduction

1.1 Purpose

This document outlines the software requirements for the DRUGHUB website, which is designed to facilitate procurement, logistics, and supply chain management for pharmaceutical products, medical devices, and essential supplies in Saudi Arabia and Egypt. The website will serve healthcare organizations by streamlining their operations and ensuring seamless access to critical resources.

1.2 Scope

The DRUGHUB website will provide a comprehensive platform for:

Managing product listings and inventories.
Facilitating procurement processes.
Streamlining logistics and supply chain operations.
Supporting communication between DRUGHUB and healthcare organizations.

**1.3 Definitions, Acronyms, and Abbreviations

HCO: Healthcare Organization
B2B: Business-to-Business
SaaS: Software as a Service

2. Overall Description

2.1 Product Perspective

The DRUGHUB website will be a standalone web application accessible via modern web browsers. It will integrate with third-party systems for payment processing, shipping, and inventory management.

2.2 Product Functions

User Management: Registration, login, and role-based access control.
Product Management: Adding, updating, and removing product listings.
Procurement: Facilitating orders, tracking, and managing procurement processes.
Logistics: Managing shipment tracking, delivery schedules, and logistics coordination.
Reporting: Generating reports on sales, inventory, and procurement metrics.
Support: Providing customer support and contact forms for inquiries.

2.3 User Classes and Characteristics

Administrators: Manage all aspects of the website, including user roles, product listings, and reporting.
Suppliers: Add and manage their products, view orders, and track shipments.
Healthcare Organizations (HCOs): Place orders, track deliveries, and manage their procurement needs.
Support Staff: Assist with customer inquiries and support requests.

This SRS document provides a comprehensive outline of the functional and non-functional requirements for the DRUGHUB website, ensuring clarity for development and implementation.

Explore website

Building a Scalable Laravel Framework with HMVC

Abdalrhman Emad Saad — Mon, 19 Aug 2024 21:14:04 +0000

Introduction

Maintaining a clean and efficient codebase is crucial for scaling applications effectively in the dynamic web development world. This article explores a Laravel-based framework I developed using the Hierarchical Model-View-Controller (HMVC) pattern, detailing its benefits and features.

Why Scaffolding?

Scaffolding in web development provides a structured framework to streamline the development process, promoting rapid application development and consistent architecture. By leveraging Laravel's robust capabilities and incorporating HMVC, this approach offers a more modular and organized method for building applications.

What Scaffolding Can Do

Enhanced Modularity: By adopting the HMVC pattern, the framework ensures a clear separation of concerns, making the codebase more maintainable and scalable. Each module operates independently, simplifying the management of complex applications.
Improved Code Organization: HMVC promotes better organization by compartmentalizing different application parts into hierarchical layers, facilitating easier updates and modifications.
Increased Reusability: Components and modules can be reused across different parts of the application or even in different projects, reducing redundancy and saving development time.
Streamlined Development: The use of scaffolding accelerates the development process by providing pre-built structures and components, allowing developers to focus on custom functionality and business logic.

Conclusion

Adopting a scaffolding approach with HMVC in Laravel offers significant advantages for building scalable, maintainable, and efficient web applications. By understanding and leveraging these benefits, developers can enhance their workflow and deliver high-quality solutions.

Explore

Samsign menu display software

Abdalrhman Emad Saad — Thu, 01 Aug 2024 13:12:11 +0000

Project Overview

The Menu Display Software is a comprehensive solution designed to facilitate businesses in displaying their menus on TVs. The software consists of a Dashboard, an Android app, and an Android TV app. This system is highly customizable and provides real-time updates, user management, analytics, and multi-language support, making it an ideal solution for restaurants, cafes, bars, and other businesses that use TVs to display their menus.

Components

Dashboard

The Dashboard serves as the central control panel for managing menus and users. It allows businesses to:

Create and manage multiple menus.
Assign images and prices to different items.
Set up schedules for displaying menus.

The Dashboard is accessible via a web browser and requires a login for secure access.

Android App

The Android app is designed for smartphones and tablets, providing a simple and intuitive interface for businesses to display their menus. It offers various templates to create and customize menus.

Android TV App

The Android TV app is optimized for TV displays, allowing businesses to showcase their menus in high definition. It supports different display modes, including split-screen, full-screen, and picture-in-picture.

Key Features

Real-time Updates: Any changes made to the menu on the Dashboard are immediately reflected on the Android app and Android TV app.
User Management: Businesses can manage users, assigning roles and permissions to control access to different parts of the system.
Multi-language Support: The software supports multiple languages, enabling businesses to create menus in different languages for their customers.

User Classes

Admin: Manages clients, creates templates, and oversees client subscriptions via the Dashboard.
User: Interacts with the system through the Android app and Android TV app, utilizing the features to manage and display menus.

Design and Implementation Constraints

Platforms: Android, Web
Programming Languages: PHP for Backend, HTML, CSS, JS for Frontend, Dart for Mobile and TV apps.
Design Constraints: The user interface must be intuitive and accessible on various devices with different screen sizes and resolutions.
Security Requirements: The software must adhere to security standards to protect sensitive information, including compliance with PCI DSS.
Performance Requirements: The software should be optimized for fast load times and minimal data usage.

Stakeholders

Project Manager & Business Analyst: Mohamed Almetwaly
Supporters: Shindar Othman, Amar
Developer: Abdalrhman Emad Saad Software developer

Functional Requirements

User Registration and Login: Users can create accounts and log in using email and password.
Menu Creation and Management: Users can create static screens for menus, design menus using templates, and schedule menu displays.
Account Management: Admins can manage user accounts, including registration approvals and password resets.
Language and Contact Options: Users can change app languages and contact admins via email or social media.

Non-Functional Requirements

Scalability: The system can be used by any business that uses menus.
Usability: The system must be user-friendly.
Availability: The system must be available at all times.
Security: User data must be secured and not shareable.
Offline Access: The app should provide some functionality even when offline.

Samsign website

Username: admin@demo.com
Password: password

This documentation provides an overview of the Menu Display Software, detailing its components, features, and requirements. This system aims to streamline the process of displaying menus for businesses, offering a versatile and secure platform for menu management.

Electronic Engineer Mobile App

Abdalrhman Emad Saad — Thu, 01 Aug 2024 13:06:39 +0000

Building the Backend for an Electronic Engineer Mobile App

As a backend developer, I contributed to a mobile application designed to streamline services for electronic engineers. The app includes features for emergency visits, service request management, and subscription plans.

Key Backend Responsibilities

Backend Architecture & API Development: Designed scalable architecture and developed RESTful APIs for seamless frontend-backend integration.
Database Management: Managed the database schema and ensured data integrity and security.
Subscription & Visit Management: Implemented systems to manage various subscription plans and schedule visits.
Payment Integration: Integrated payment gateways for processing transactions and implemented refund mechanisms.
Security & Optimization: Secured the backend against vulnerabilities and optimized for performance.

Technologies Used

Framework: Laravel
Database: MySQL
APIs: RESTful APIs

Preview

Explore

DEV Community: Abdalrhman Emad Saad

Stop Writing Filter Logic in Controllers — Meet Filterable for Laravel

The Complete Guide to Filterable: Clean, Scalable Eloquent Filtering for Laravel

Installation

Your First Filter

Binding the Filter to Your Model

Choosing an Engine

1. Invokable Engine

2. Ruleset Engine

3. Expression Engine

4. Tree Engine

Validation & Sanitization

Authorization

Sorting

Caching

CLI Reference

Wrapping Up

Stop Writing Messy Queries in Laravel — Meet kettasoft/filterable 🚀

✨ Meet kettasoft/filterable

⚡ Before vs After

❌ Without filterable:

✅ With filterable:

🛠 Example Filter

🔧 Sorting Support

🌍 Why use kettasoft/filterable?

📦 Installation

📝 Final Thoughts

Scaffolding

Main Function Points

Technology Stack

License

Smart student

Software Requirements Specification (SRS) for DRUGHUB

1. Introduction

1.1 Purpose

1.2 Scope

2. Overall Description

Building a Scalable Laravel Framework with HMVC

Introduction

Why Scaffolding?

What Scaffolding Can Do

Conclusion

Samsign menu display software

Project Overview

Components

Dashboard

Android App

Android TV App

Key Features

User Classes

Design and Implementation Constraints

Stakeholders

Functional Requirements

Non-Functional Requirements

Electronic Engineer Mobile App

Building the Backend for an Electronic Engineer Mobile App

Key Backend Responsibilities

Technologies Used

Preview

✨ Meet `kettasoft/filterable`

❌ Without `filterable`:

✅ With `filterable`:

🌍 Why use `kettasoft/filterable`?