​

Introduction

​

What is Rest Generic Class?

• Dynamic filtering with a structured query syntax
• Smart relation loading with field selection
• Hierarchical data support for tree structures
• Advanced caching with configurable backends (Redis, database, file, memcached)
• Role-based field restrictions for sensitive data
• Bulk operations (update multiple, delete multiple)
• Export capabilities (Excel, PDF)

​

Key Benefits

​

Architecture Overview

​

BaseModel (extends Eloquent Model)

• Relation allowlists via const RELATIONS - explicitly declare which relations can be queried
• Hierarchy support via const HIERARCHY_FIELD_ID - enable tree structures (categories, org charts, etc.)
• Role-based field restrictions - control which user roles can write sensitive fields
• Scenario-based validation - different rules for create vs update operations
• Parent model support - for single-table inheritance patterns

use Ronu\RestGenericClass\Core\Models\BaseModel;

class Product extends BaseModel
{
    protected $fillable = ['name', 'price', 'stock', 'category_id'];

    const MODEL = 'product';
    const RELATIONS = ['category', 'reviews'];  // Allowlisted relations

    public function category()
    {
        return $this->belongsTo(Category::class);
    }

    public function reviews()
    {
        return $this->hasMany(Review::class);
    }
}

​

BaseService (Business Logic Layer)

• Dynamic filtering - parse and apply complex filter trees with nested relations
• Relation loading - eager load with field selection (e.g., category:id,name)
• Pagination - both offset-based and cursor-based pagination
• Hierarchy queries - list tree structures with configurable depth
• Cache management - automatic caching with version-based invalidation
• Bulk operations - create/update multiple records in a transaction

use Ronu\RestGenericClass\Core\Services\BaseService;

class ProductService extends BaseService
{
    public function __construct()
    {
        parent::__construct(Product::class);
    }
    
    // All CRUD methods inherited:
    // - list_all($params)
    // - get_one($params)
    // - create($data)
    // - update($data, $id)
    // - destroy($id)
    // - update_multiple($data)
}

​

RestController (HTTP Layer)

• Standard REST endpoints - index, show, store, update, destroy
• Query parameter parsing - extract and normalize request parameters
• Transaction management - automatic DB transactions for write operations
• Error handling - parse database errors into user-friendly messages
• Export endpoints - Excel and PDF generation

use Ronu\RestGenericClass\Core\Controllers\RestController;

class ProductController extends RestController
{
    protected $modelClass = Product::class;

    public function __construct(ProductService $service)
    {
        $this->service = $service;
    }
    
    // All REST methods inherited:
    // - index(Request)      -> GET /products
    // - show(Request, $id)  -> GET /products/{id}
    // - store(Request)      -> POST /products
    // - update(Request, $id)-> PUT /products/{id}
    // - destroy($id)        -> DELETE /products/{id}
    // - updateMultiple(Request) -> POST /products/update-multiple
}

​

Who Should Use This Package?

​

Perfect For:

• API-first applications that need flexible query capabilities without GraphQL complexity
• Admin dashboards with dynamic tables, filters, and relation loading
• Multi-tenant SaaS applications with role-based access control requirements
• Data-heavy applications that need hierarchical structures (categories, org charts, menus)
• Teams wanting to standardize REST API patterns across services

​

Consider Alternatives If:

• You need GraphQL - this package focuses on REST conventions
• You have non-standard REST patterns - the package works best with conventional CRUD
• You prefer repositories over services - the package uses a service layer pattern
• You need JSONAPI spec compliance - this uses a custom (but consistent) query format

​

Use Cases

​

Package Philosophy

1. Security First - Relations must be explicitly allowlisted. Query depth is limited. Operators are configurable.
2. Convention Over Configuration - Sensible defaults for 80% of use cases. Override when needed.
3. Performance Matters - Generic caching, query optimization, and efficient eager loading.
4. Laravel Native - Uses Laravel’s query builder, cache, validation, and conventions throughout.
5. Type Safety - PHP 8.0+ with proper type hints and strict types where appropriate.

​

What You’ll Learn

• Get Started (you are here) - Introduction, concepts, and quickstart
• Configuration - Environment variables, cache setup, and publishing config
• Usage - Basic and advanced usage patterns with real examples
• Reference - Complete API reference, middleware, exceptions, and validation rules
• Quality - Security, testing, troubleshooting, and FAQ