Simple to use Caching Repository for Laravel Eloquent

1.0.6 2017-03-03 17:37 UTC

This package is not auto-updated.

Last update: 2020-02-21 16:27:35 UTC


This laravel package gives a fluid way to cache your queries while speeding up your Eloquent workflow.


Install the composer package

composer require "drapor/cache-repository"

Add the service Provider to your app.php


Publish the config

` php artisan vendor:publish `


Step 1 : Modify our Model

  <?php namespace app\Models;

      use Drapor\CacheRepository\Eloquent\BaseModel;

         class User extends BaseModel
         { ... }

Step 2: Create a Repository Class

  <?php namespace app\Repositories;
  use Drapor\CacheRepository\CacheRepository;
     class UserRepository extends CacheRepository
        public function __construct(User $user)
          parent::__construct($user, 'user');
          //Create a Relation instance and pass the second argument as a boolean
          //indicating wether or not it should be removed from the cache when the User object is updated.
          $task = new Relation('task',true);
          //Only call $this->setRelations() if you wish to eager load these relations before every call. This method accepts both
          //instances of Relation and strings. 

            'group', $task

Now You can Inject the Repository wherever you need to use it. This can be done in quite a few ways due to Laravel's magic, but we're going to keep it simple and use a common example.

Step 3 : Inject The Repo

 <?php namespace app/controllers;

 use Repositories/UserRepository; 
 use Request;

 class UserController extends Controller

protected $repository;  

public function __construct(UserRepository $repository)
  $this->repository = $repository;

public function index()
   $limit = Request::input('limit');

   $users = $this->repository

   return response()->json($users);

public function getSadUsers()
   $limit = Request::input('limit');

   //Paginate accepts a second argument for search parameters.
   //This should be an array of arrays, each with at least a key and a value.

   $params =  [
      'key'   => 'sad',
      'value' => 'true'
       'key'        => 'happiness',
        'operator'  => '<',
        'value'     => '2',
        'keyword'   => 'AND'

   //Alternatively you can call Argument::extract(Request::input(),'search')
   //and any search information will automatically be formatted

   $users = $this->repository

   return response()->json($users->toJson());


public function find($id)
  $user = $this->repository->with('tasks')->find($id);

  return response()->json($user->toJson());

public function update($id)
   //The Repository class will automatically clean out any input
   //that isn't fillable by our model.
   $user = $this->repository->update($id,Request::input());

    return response()->json($user->toJson());

What should I know?

  • Cache can be disabled for any query at any time by calling

    $user = $this->repository->noCache()->find($id); or by using the PlainRepository class instead.

  • Calls to the paginate() method are not cached at this time. If you wish to cache a collection, you should use the whereCached() method directly from your Repository
  • You can alter the time a model is cached by calling setCacheLifeTime() before any method

Planned Feature List

  • Cached json serialization of each entity. $books = $this->respository ->with('books') ->whereCached('name','harry-potter')-> ->transformTo(BookTransformer::class);
  • Caching support for more complex queries, joins, raws, etc
  • Global broadcasting of regular model events. Create, delete, restore, etc.
  • Fluid cache for pagination responses, that is updated when an element of the collection is modified and does not modify the whole collection each time.


The do-whatever-you-want-with-it attributation