Added automatic cache invalidation

Author: rennokki

README.md

@@ -150,6 +150,80 @@ $user = User::with(['orders' => function ($query) {
 $orders = $user->orders;
 ```
 
+## Full Automatic Invalidation
+
+To speed up the scaffolding of invalidation within your app, you can specify the model to auto-flush the cache upon any model gets created, updated or deleted.
+
+```php
+class Page extends Model
+{
+    use QueryCacheable;
+
+    /**
+     * Invalidate the cache automatically
+     * upon update in the database.
+     */
+    protected static $flushCacheOnUpdate = true;
+}
+```
+
+When you set up the `$flushCacheOnUpdate` variable, the package attaches an observer to your model, and any `created`, `updated`, `deleted`, `forceDeleted` or `restored` event will trigger the cache invalidation.
+
+> In order for auto-flush to work, you will need at least one **base tag**. Out-of-the-box, the model has a base tag set. In some cases, if you have overwritten the `getCacheBaseTags()` with an empty array, it might not work.
+
+## Partial Automatic Invalidation
+
+In some cases, you might not want to invalidate the whole cache of a specific model. Perhaps you got two queries that run individually and want to invalidate the cache only for one of them.
+
+To do this, overwrite your `getCacheTagsToInvalidateOnUpdate()` method in your model:
+
+```php
+class Page extends Model
+{
+    use QueryCacheable;
+
+    /**
+     * Invalidate the cache automatically
+     * upon update in the database.
+     */
+    protected static $flushCacheOnUpdate = true;
+
+    /**
+     * When invalidating automatically on update, you can specify
+     * which tags to invalidate.
+     *
+     * @return array
+     */
+    public function getCacheTagsToInvalidateOnUpdate(): array
+    {
+        return [
+            'query1',
+        ];
+    }
+}
+
+$query1 = Page::cacheFor(60)
+    ->cacheTags(['query1'])
+    ->get();
+
+$query2 = Page::cacheFor(60)
+    ->cacheTags(['query2'])
+    ->get();
+
+// The $query1 gets invalidated
+// but $query2 will still hit from cache if re-called.
+
+$page = Page::first();
+
+$page->update([
+    'name' => 'Reddit',
+]);
+```
+
+**Please keep in mind: Setting `$flushCacheOnUpdate` to `true` and not specifying individual tags to invalidate will lead to [Full Automatic Invalidation](#full-automatic-invalidation) since the default tags to invalidate are the base tags and you need at least one tag to invalidate.**
+
+**Not specifying a tag to invalidate fallbacks to the set of base tags, thus leading to Full Automatic Invalidation.**
+
 ## Cache Keys
 
 The package automatically generate the keys needed to store the data in the cache store. However, prefixing them might be useful if the cache store is used by other applications and/or models and you want to manage the keys better to avoid collisions.

database/factories/PageFactory.php

@@ -0,0 +1,19 @@
+<?php
+/*
+|--------------------------------------------------------------------------
+| Model Factories
+|--------------------------------------------------------------------------
+|
+| This directory should contain each of the model factory definitions for
+| your application. Factories provide a convenient way to generate new
+| model instances for testing / seeding your application's database.
+|
+*/
+
+use Illuminate\Support\Str;
+
+$factory->define(\Rennokki\QueryCache\Test\Models\Page::class, function () {
+    return [
+        'name' => 'Page'.Str::random(5),
+    ];
+});

src/FlushQueryCacheObserver.php

@@ -0,0 +1,83 @@
+<?php
+
+namespace Rennokki\QueryCache;
+
+use Illuminate\Database\Eloquent\Model;
+
+class FlushQueryCacheObserver
+{
+    /**
+     * Handle the Model "created" event.
+     *
+     * @param  \Illuminate\Database\Eloquent\Model  $model
+     * @return void
+     */
+    public function created(Model $model)
+    {
+        $this->invalidateCache($model);
+    }
+
+    /**
+     * Handle the Model "updated" event.
+     *
+     * @param  \Illuminate\Database\Eloquent\Model  $model
+     * @return void
+     */
+    public function updated(Model $model)
+    {
+        $this->invalidateCache($model);
+    }
+
+    /**
+     * Handle the Model "deleted" event.
+     *
+     * @param  \Illuminate\Database\Eloquent\Model  $model
+     * @return void
+     */
+    public function deleted(Model $model)
+    {
+        $this->invalidateCache($model);
+    }
+
+    /**
+     * Handle the Model "forceDeleted" event.
+     *
+     * @param  \Illuminate\Database\Eloquent\Model  $model
+     * @return void
+     */
+    public function forceDeleted(Model $model)
+    {
+        $this->invalidateCache($model);
+    }
+
+    /**
+     * Handle the Model "restored" event.
+     *
+     * @param  \Illuminate\Database\Eloquent\Model  $model
+     * @return void
+     */
+    public function restored(Model $model)
+    {
+        $this->invalidateCache($model);
+    }
+
+    /**
+     * Invalidate the cache for a model.
+     *
+     * @param  \Illuminate\Database\Eloquent\Model  $model
+     * @return void
+     * @throws Exception
+     */
+    protected function invalidateCache(Model $model): void
+    {
+        if (! $model->getCacheTagsToInvalidateOnUpdate()) {
+            throw new Exception('Automatic invalidation for '.$class.' works only if at least one tag to be invalidated is specified.');
+        }
+
+        $class = get_class($model);
+
+        $class::flushQueryCache(
+            $model->getCacheTagsToInvalidateOnUpdate()
+        );
+    }
+}

src/Traits/QueryCacheable.php

@@ -2,10 +2,50 @@
 
 namespace Rennokki\QueryCache\Traits;
 
+use Illuminate\Database\Eloquent\Model;
+use Rennokki\QueryCache\FlushQueryCacheObserver;
 use Rennokki\QueryCache\Query\Builder;
 
 trait QueryCacheable
 {
+    /**
+     * Get the observer class name that will
+     * observe the changes and will invalidate the cache
+     * upon database change.
+     *
+     * @return string
+     */
+    protected static function getFlushQueryCacheObserver()
+    {
+        return FlushQueryCacheObserver::class;
+    }
+
+    /**
+     * When invalidating automatically on update, you can specify
+     * which tags to invalidate.
+     *
+     * @return array
+     */
+    public function getCacheTagsToInvalidateOnUpdate(): array
+    {
+        return $this->getCacheBaseTags();
+    }
+
+    /**
+     * {@inheritdoc}
+     *
+     */
+    public static function boot()
+    {
+        parent::boot();
+
+        if (isset(static::$flushCacheOnUpdate) && static::$flushCacheOnUpdate) {
+            static::observe(
+                static::getFlushQueryCacheObserver()
+            );
+        }
+    }
+
     /**
      * {@inheritdoc}
      */

tests/FlushCacheOnUpdateTest.php

@@ -0,0 +1,94 @@
+<?php
+
+namespace Rennokki\QueryCache\Test;
+
+use Cache;
+use Rennokki\QueryCache\Test\Models\Page;
+use Rennokki\QueryCache\Test\Models\Post;
+
+class FlushCacheOnUpdateTest extends TestCase
+{
+    public function test_flush_cache_on_create()
+    {
+        $page = factory(Page::class)->create();
+        $storedPage = Page::cacheFor(now()->addHours(1))->first();
+        $cache = Cache::tags(['test'])->get('leqc:sqlitegetselect * from "pages" limit 1a:0:{}');
+
+        $this->assertNotNull($cache);
+
+        $this->assertEquals(
+            $cache->first()->id,
+            $storedPage->id
+        );
+
+        Page::create([
+            'name' => '9GAG',
+        ]);
+
+        $cache = Cache::tags(['test'])->get('leqc:sqlitegetselect * from "pages" limit 1a:0:{}');
+
+        $this->assertNull($cache);
+    }
+
+    public function test_flush_cache_on_update()
+    {
+        $page = factory(Page::class)->create();
+        $storedPage = Page::cacheFor(now()->addHours(1))->first();
+        $cache = Cache::tags(['test'])->get('leqc:sqlitegetselect * from "pages" limit 1a:0:{}');
+
+        $this->assertNotNull($cache);
+
+        $this->assertEquals(
+            $cache->first()->id,
+            $storedPage->id
+        );
+
+        $page->update([
+            'name' => '9GAG',
+        ]);
+
+        $cache = Cache::tags(['test'])->get('leqc:sqlitegetselect * from "pages" limit 1a:0:{}');
+
+        $this->assertNull($cache);
+    }
+
+    public function test_flush_cache_on_delete()
+    {
+        $page = factory(Page::class)->create();
+        $storedPage = Page::cacheFor(now()->addHours(1))->first();
+        $cache = Cache::tags(['test'])->get('leqc:sqlitegetselect * from "pages" limit 1a:0:{}');
+
+        $this->assertNotNull($cache);
+
+        $this->assertEquals(
+            $cache->first()->id,
+            $storedPage->id
+        );
+
+        $page->delete();
+
+        $cache = Cache::tags(['test'])->get('leqc:sqlitegetselect * from "pages" limit 1a:0:{}');
+
+        $this->assertNull($cache);
+    }
+
+    public function test_flush_cache_on_force_deletion()
+    {
+        $page = factory(Page::class)->create();
+        $storedPage = Page::cacheFor(now()->addHours(1))->first();
+        $cache = Cache::tags(['test'])->get('leqc:sqlitegetselect * from "pages" limit 1a:0:{}');
+
+        $this->assertNotNull($cache);
+
+        $this->assertEquals(
+            $cache->first()->id,
+            $storedPage->id
+        );
+
+        $page->forceDelete();
+
+        $cache = Cache::tags(['test'])->get('leqc:sqlitegetselect * from "pages" limit 1a:0:{}');
+
+        $this->assertNull($cache);
+    }
+}

tests/Models/Page.php

@@ -0,0 +1,26 @@
+<?php
+
+namespace Rennokki\QueryCache\Test\Models;
+
+use Illuminate\Database\Eloquent\Model;
+use Rennokki\QueryCache\Traits\QueryCacheable;
+
+class Page extends Model
+{
+    use QueryCacheable;
+
+    protected static $flushCacheOnUpdate = true;
+
+    protected $cacheUsePlainKey = true;
+
+    protected $fillable = [
+        'name',
+    ];
+
+    protected function getCacheBaseTags(): array
+    {
+        return [
+            'test',
+        ];
+    }
+}

tests/TestCase.php

@@ -57,6 +57,7 @@ public function getEnvironmentSetUp($app)
         $app['config']->set('auth.providers.posts.model', Post::class);
         $app['config']->set('auth.providers.kids.model', Kid::class);
         $app['config']->set('auth.providers.books.model', Book::class);
+        $app['config']->set('auth.providers.pages.model', Page::class);
         $app['config']->set('app.key', 'wslxrEFGWY6GfGhvN9L3wH3KSRJQQpBD');
     }
 

tests/database/migrations/2018_07_14_183253_pages.php

@@ -0,0 +1,32 @@
+<?php
+
+use Illuminate\Database\Migrations\Migration;
+use Illuminate\Database\Schema\Blueprint;
+use Illuminate\Support\Facades\Schema;
+
+class Pages extends Migration
+{
+    /**
+     * Run the migrations.
+     *
+     * @return void
+     */
+    public function up()
+    {
+        Schema::create('pages', function (Blueprint $table) {
+            $table->increments('id');
+            $table->string('name');
+            $table->timestamps();
+        });
+    }
+
+    /**
+     * Reverse the migrations.
+     *
+     * @return void
+     */
+    public function down()
+    {
+        Schema::dropIfExists('pages');
+    }
+}