Handling Statamic static cache invalidation on large sites

'invalidation' => [

    'class' => null,

    'rules' => [
        'collections' => [
            'events' => [
                'urls' => [
                    '/',
                    '/whats-on',
                    '/visit/locations-and-times/*',
                ],
            ],
            // ...
        ],
    ],

],

<?php

namespace App\Listeners\StaticCaching;

use Illuminate\Contracts\Queue\ShouldQueue;
use Illuminate\Queue\InteractsWithQueue;
use Illuminate\Support\Arr;
use Illuminate\Support\Facades\File;
use Illuminate\Support\Facades\Log;

class ForceEntryInvalidation implements ShouldQueue
{
    use InteractsWithQueue;

    protected $rules = [
        'posts' => [
            'urls' => [
                '/',
                '/about/news',
            ],
        ],
    ];

    protected $deleted = [];

    /**
     * Create the event listener.
     *
     * @return void
     */
    public function __construct()

    {
        //
    }

    /**
     * Handle the event.
     *
     * @param  object  $event
     * @return void
     */
    public function handle($event)
    {
        /** @var \Statamic\Entries\Entry */
        $entry = $event->entry;

        // Delete itself
        if ($uri = $entry->uri()) {
            $this->invalidatePath($uri);
        }

		  // If it's a page & it has a parent entry, let's invalidate it & warm it back up again.
        if ($entry->collectionHandle() === 'pages' && $entry->parent()) {
            $this->invalidatePath($entry->parent()->uri());

            $this->visit($entry->parent()->uri());
        }

        // Loop through any rules
        foreach (Arr::get($this->rules, "{$entry->collectionHandle()}.urls", []) as $rule) {
            // Is this a wildcard rule?
            if (str_contains($rule, '*')) {
                $staticCachingPaths = File::glob(public_path('static').$rule.'_.html');

                foreach ($staticCachingPaths as $staticCachingPath) {
                    $this->deleted[] = $staticCachingPath;

                    File::delete($staticCachingPath);
                }

                continue;
            }

            $this->invalidatePath($rule);
        }

        Log::info("Entry {$entry->slug()} saved, paths invalidated", $this->deleted);

    }

    protected function invalidatePath(string $path = '/')
    {
        // We could have multiple paths (since we need to clear query parameters too..)
        $filePaths = array_merge(
            [public_path('static').$path],
            File::glob(public_path('static').$path.'_*.html'),
        );

        foreach ($filePaths as $filePath) {
            $this->deleted[] = $filePath;
            File::delete($filePath);
        }
    }
}

<?php

namespace App\Console\Commands;

use App\Events\ScheduledEntryPublished;
use Illuminate\Console\Command;
use Statamic\Facades\Entry;

class ClearCacheForScheduledEntries extends Command
{
    /**
     * The name and signature of the console command.
     *
     * @var string
     */
    protected $signature = 'steadfast:clear-cache-for-scheduled-entries';

    /**
     * The console command description.
     *
     * @var string
     */
    protected $description = 'Clears the static cache when scheduled entries are published.';

    /**
     * Create a new command instance.
     *
     * @return void
     */
    public function __construct()
    {
        parent::__construct();
    }

    /**
     * Execute the console command.
     *
     * @return int
     */
    public function handle()
    {
        $this->info('Clearing the cache for scheduled entries...');

        Entry::query()
            ->whereIn('collection', ['posts', 'recommendations'])
            ->where('date', now()->startOfDay())
            ->get()
            ->each(function ($entry) {
                event(new ScheduledEntryPublished($entry));
            });
    }
}

<?php

namespace App\Console\Commands;

use Illuminate\Console\Command;
use Illuminate\Support\Facades\File;
use Illuminate\Support\Facades\Http;
use Statamic\Facades\Entry;

class RebuildStaticCache extends Command
{
    /**
     * The name and signature of the console command.
     *
     * @var string
     */
    protected $signature = 'steadfast:rebuild-static-cache';

    /**
     * The console command description.
     *
     * @var string
     */
    protected $description = 'Rebuilds the static cache by clearing & warming popular pages.';

    protected $staticCachingPath;

    /**
     * Create a new command instance.
     *
     * @return void
     */
    public function __construct()
    {
        parent::__construct();

        $this->staticCachingPath = config('statamic.static_caching.strategies.full.path');
    }

    /**
     * Execute the console command.
     *
     * @return int
     */
    public function handle()
    {
        $this->info('Rebuilding static cache...');

        // Invalidate & warm popular pages
        foreach ($this->popularPages() as $uri) {
            foreach (File::glob($this->staticCachingPath.'/'.$uri.'*') as $file) {
                File::delete($file);
            }

            $this->visit($uri);
        }

        return Command::SUCCESS;
    }

    protected function popularPages()
    {
        $popularPages = [
            '/',
            '/whats-on',
            '/borrow',
            '/about',
            '/about/news',
            '/about/newsletter',
        ];

        // Get the 20 latest blog posts
        Entry::whereCollection('posts')->map(function ($post) {
            return [
                'uri' => $post->uri(),
                'date' => $post->date->timestamp,
            ];
        })->sortByDesc('date')->limit(20)->pluck('uri')->map(function ($uri) use (&$popularPages) {
            $popularPages[] = $uri;
        });

        return $popularPages;
    }

    protected function visit(string $url = '/'): void
    {
        $this->info("Generating: {$url}");

        $request = Http::get(config('app.url').$url);

        if ($request->failed()) {
            $this->error("Failed to generate: {$url}");
        }
    }
}