Redis als Cache-Layer in Statamic: Patterns, die wirklich greifen

return [
    'default' => env('CACHE_STORE', 'redis'),

    'stores' => [
        'redis' => [
            'driver' => 'redis',
            'connection' => env('REDIS_CACHE_CONNECTION', 'cache'),
            'lock_connection' => env('REDIS_CACHE_LOCK_CONNECTION', 'default'),
        ],

        // Eigener Store nur für Statamic Static Caching - auf einer
        // separaten Redis-DB, damit Cache::flush() nicht das ganze
        // Static Cache wegräumt.
        'statamic_static' => [
            'driver' => 'redis',
            'connection' => 'statamic_static',
            'lock_connection' => 'default',
        ],
    ],

    // Prefix pro Environment, damit Staging und Production sich nicht
    // gegenseitig die Keys überschreiben, falls sie denselben Redis nutzen.
    'prefix' => env('CACHE_PREFIX', env('APP_NAME', 'app') . '_cache_' . env('APP_ENV', 'production')),
];

// .env (Auszug)
// REDIS_CLIENT=phpredis
// REDIS_HOST=127.0.0.1
// REDIS_PORT=6379
// CACHE_STORE=redis
// REDIS_CACHE_CONNECTION=cache

return [
    // 'half' lässt Antlers rendern, cached aber Tag-Resultate.
    // 'full' cached den kompletten HTML-Response. 'null' = aus.
    'strategy' => env('STATAMIC_STATIC_CACHING_STRATEGY', 'half'),

    'strategies' => [
        'half' => [
            'driver' => 'cache',
            'expiry' => null, // null = unendlich, wir invalidieren via Hook
        ],

        'full' => [
            'driver' => 'application',
            'expiry' => null,
            'lock_hold_length' => 0,
        ],
    ],

    // Eigener Cache-Store, damit Cache::flush() das Static Cache
    // nicht versehentlich wegräumt.
    'cache_store' => 'statamic_static',

    // Regeln, wann beim Speichern eines Entries invalidiert wird.
    'invalidation' => [
        'class' => null, // Default. Erweitern wir gleich per Hook.
        'rules' => [
            'collections' => [
                'pages'     => ['urls' => ['/', '/{slug}']],
                'tutorials' => ['urls' => ['/de/tutorials', '/de/tutorials/{slug}']],
                'glossary'  => ['urls' => ['/de/glossar', '/de/glossar/{slug}']],
            ],
        ],
    ],

    // Pfade, die niemals gecacht werden (CP, Login, dynamische APIs).
    'exclude' => [
        '/cp', '/cp/*',
        '/!/*',
        '/api/*',
    ],
];

use Illuminate\Support\Facades\Cache;
use Illuminate\Support\ServiceProvider;
use Statamic\Events\EntrySaved;
use Statamic\Events\EntryDeleted;
use Statamic\Events\GlobalSetSaved;
use Statamic\Events\TermSaved;
use Statamic\StaticCaching\Cacher;

class CacheInvalidationServiceProvider extends ServiceProvider
{
    public function boot(Cacher $staticCacher): void
    {
        // Entry geändert → nur die betroffenen Tag-Gruppen räumen.
        EntrySaved::listen(function (EntrySaved $event) use ($staticCacher) {
            $entry = $event->entry;
            $handle = $entry->collection()->handle();

            // App-Cache: Tags pro Collection.
            Cache::tags([$handle, 'nav'])->flush();

            // Statamic Static Cache: nur diese URL invalidieren.
            $staticCacher->invalidateUrl($entry->url());
        });

        // Gelöschter Entry → URL aus Static Cache räumen.
        EntryDeleted::listen(function (EntryDeleted $event) use ($staticCacher) {
            $url = $event->entry->url();
            if ($url) {
                $staticCacher->invalidateUrl($url);
            }
            Cache::tags([$event->entry->collection()->handle()])->flush();
        });

        // Global-Set (z. B. Navigation, Footer) → Site-weit räumen.
        GlobalSetSaved::listen(function () use ($staticCacher) {
            Cache::tags(['nav', 'footer', 'globals'])->flush();
            $staticCacher->flush();
        });

        // Taxonomie (z. B. Tags, Categories) → betroffenen Handle räumen.
        TermSaved::listen(function (TermSaved $event) {
            Cache::tags([$event->term->taxonomy()->handle()])->flush();
        });
    }
}