Understanding Static Caching – Strategy Half

[eliasu]

Hi there,

I´m trying to wrap my head around the static caching, and I have some questions:

If I'm setting STATAMIC_STATIC_CACHING_STRATEGY=half I'm activating half measure caching like it says in the docs and … its very fast :)

And since "full measure" is a little too much for me atm with server settings, nginx, etc. I want to go with "half" … So what's the draw back? If I'm understanding correctly, with every content save, the corresponding "cache item" gets "freshly cached" as it says here:

When saving content, the corresponding item’s URL will be flushed from the static cache automatically.

So two questions:

1. I have "related entries (events)" in a collection "artists". They have a many-to-many relation via this addon. So I'm assuming, if the artists is edited and saved, it gets invalidated everywhere its content is used (in the index page, the show page, anywhere {{collection:artists}} is used, correct? But what about the related entries? Do I have to invalidate those entries via a specific rule, or do they get invalidated automatically? And if so, how to declare related entries in the static_caching.php?

2. I dont really get what I have to wrap into {nochache}tags … ok dynamic content, but: For example, I have a list of artists, which I filter via Alpine.js. So no need for {nocache} because they are are static, right? And If there are changes to one artists, it will automatically invalidate, because its saved again and therefore invalidated, correct?

3. Second Example: I have an artist "show/detail" page, where there are listed the upcoming events. This is done like so {{ events events:start_date:is_after="today" }}. Seems dynamic … but, if I make changes to an event, or I make changes to an artist, this will – again – invalidate the artists page. So where is the need for a {nochache}tag? And more importanly, did I get something wrong here?

Thanks a lot!

[jasonvarga]

The real draw back is that it's a bit slower. Laravel still has to boot up on every request.

Everything else pretty much works the same way.

When saving content, the corresponding item’s URL will be flushed from the static cache automatically.

That line is saying that only that item's URL will be invalidated. e.g. if you save the entry that lives at /blog/my-post - only /blog/my-post will get invalidated. If you're referencing /blog/my-post in other places, like a listing (/blog), it won't automatically get invalidated there.

You'll need to set up the invalidation rules. e.g. You should set it up so that when you save a blog entry, you'll also want to invalidate the blog listing.

On your Alpine driven listing, if you're always getting all the artists and then just filtering them down with JS, then you're correct in that you don't need the nocache tag. But, you'll wanna make sure to invalidate this URL when you save an artist.

Same deal with the events listing. Adjust your rules so that when you save an event, it'll invalidate that listing.

[eliasu]

Thanks Jason!

Ok so I use this syntax to declare special rules:

return [
    'class' => null,
    'invalidation' => [
        'rules' => [
            'collections' => [
                'blog' => [
                    'urls' => [
                        '/blog',
                        '/blog/category/*',
                        '/',
                    ]
                ],
            ],
        ]
    ]
];

1. So far so good … but how to address related entries with this syntax? I don't want to invalidate the whole "events collection" if I'm changing one artists event, right?

2. And how about this: I build a page builder (article with sets), and one of those sets uses a collection lists of "artists". I don't know, on which page this block will be used. So how would you do this?

3. And last but not least, does invalidation mean, the stache gets warmed as well? Or is it slow on the first next visit again?

🙏

[ryanmitchell]

for 1 and 2 you can create your own CacheInvalidator class and then write the logic to do this, for example heres a bit of one of ours:

<?php

namespace App\Caching;

use Illuminate\Support\Collection;
use Illuminate\Support\Facades\Cache;
use Statamic\Contracts\Entries\Entry;
use Statamic\Contracts\Globals\GlobalSet;
use Statamic\Contracts\Structures\Nav;
use Statamic\Contracts\Structures\NavTree;
use Statamic\Contracts\Taxonomies\Term;
use Statamic\Facades;
use Statamic\Statamic;
use Statamic\StaticCaching\DefaultInvalidator;

class CacheInvalidator extends DefaultInvalidator
{
    public function invalidate($item)
    {
        if ($this->rules === 'all') {
            return $this->cacher->flush();
        }

        $urls = false;

        if ($item instanceof Entry) {
            $urls = $this->clearCacheForEntry($item);

            if ($url = $item->url()) {
                $urls->push($url);
            }
        } else if ($item instanceof GlobalSet) {
            $urls = $this->clearCacheForGlobal($item);
        } else if ($item instanceof Nav) {
            $urls = $this->clearCacheForNav($item);
        } else if ($item instanceof CollectionTree) {
            $urls = $this->clearCacheForCollectionTree($item);
        } else if ($item instanceof NavTree) {
            $urls = $this->clearCacheForNavTree($item);
        } else if ($item instanceof Term) {
            $urls = $this->clearCacheForTerm($item);
        } else if ($item instanceof Collection) {
            $urls = $item;
        }

        if ($urls instanceof Collection) {
            $this->cacher->invalidateUrls($urls->all());
        }
    }

    private function clearCacheForEntry($entry): ?Collection
    {
        switch ($entry->collection())
        {
            case 'series':
                $urls = collect($entry->urls);
                return $urls->map(function ($url) {
                    return '/series/'.$url;
                });
            break;

You specify it in the statamic.static_caching.invalidator.class config key