├── tests
    ├── __fixtures__
    │   ├── dev-null
    │   │   └── .gitkeep
    │   └── resources
    │   │   └── views
    │   │       ├── default.antlers.html
    │   │       └── layout.antlers.html
    ├── Unit
    │   ├── AdditionalTrackerTest.php
    │   ├── EventListenerTest.php
    │   └── TrackerTest.php
    └── TestCase.php
├── config
    └── statamic-cache-tracker.php
├── .gitignore
├── src
    ├── Events
    │   ├── TrackContentTags.php
    │   └── ContentTracked.php
    ├── Facades
    │   └── Tracker.php
    ├── Jobs
    │   └── InvalidateTags.php
    ├── Http
    │   ├── Controllers
    │   │   ├── GetTagsController.php
    │   │   ├── GetUrlsController.php
    │   │   └── UtilityController.php
    │   └── Middleware
    │   │   └── CacheTracker.php
    ├── Actions
    │   ├── ClearCache.php
    │   └── ViewCacheTags.php
    ├── ServiceProvider.php
    ├── Tracker
    │   └── Manager.php
    └── Listeners
    │   └── Subscriber.php
├── .editorconfig
├── resources
    └── js
    │   ├── cp.js
    │   ├── pages
    │       └── ClearUtility.vue
    │   └── components
    │       └── CacheTrackerModal.vue
├── routes
    └── cp.php
├── package.json
├── vite.config.js
├── README.md
├── phpunit.xml
├── .github
    └── workflows
    │   ├── tests.yml
    │   └── release.yaml
└── composer.json


/tests/__fixtures__/dev-null/.gitkeep:
--------------------------------------------------------------------------------
1 | 


--------------------------------------------------------------------------------
/tests/__fixtures__/resources/views/default.antlers.html:
--------------------------------------------------------------------------------
1 | <!-- TEMPLATE: default -->
2 | 
3 | <h1>{{ title }}</h1>
4 | 


--------------------------------------------------------------------------------
/tests/__fixtures__/resources/views/layout.antlers.html:
--------------------------------------------------------------------------------
1 | <!-- LAYOUT: layout -->
2 | 
3 | {{ template_content }}
4 | 


--------------------------------------------------------------------------------
/config/statamic-cache-tracker.php:
--------------------------------------------------------------------------------
1 | <?php
2 | 
3 | return [
4 |     'enabled' => env('STATAMIC_CACHE_TRACKER_ENABLED', true),
5 | ];
6 | 


--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
 1 | /.phpunit.cache
 2 | /dist
 3 | /node_modules
 4 | /vendor
 5 | composer.lock
 6 | mix-manifest.json
 7 | package-lock.json
 8 | yarn.lock
 9 | .idea/*
10 | 


--------------------------------------------------------------------------------
/src/Events/TrackContentTags.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Thoughtco\StatamicCacheTracker\Events;
 4 | 
 5 | use Statamic\Events\Event;
 6 | 
 7 | class TrackContentTags extends Event
 8 | {
 9 |     public function __construct(public array $tags) {}
10 | }
11 | 


--------------------------------------------------------------------------------
/src/Events/ContentTracked.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Thoughtco\StatamicCacheTracker\Events;
 4 | 
 5 | use Statamic\Events\Event;
 6 | 
 7 | class ContentTracked extends Event
 8 | {
 9 |     public function __construct(public string $url, public array $tags) {}
10 | }
11 | 


--------------------------------------------------------------------------------
/.editorconfig:
--------------------------------------------------------------------------------
 1 | root = true
 2 | 
 3 | [*]
 4 | charset = utf-8
 5 | end_of_line = lf
 6 | insert_final_newline = true
 7 | indent_style = space
 8 | indent_size = 4
 9 | trim_trailing_whitespace = true
10 | 
11 | [*.md]
12 | trim_trailing_whitespace = false
13 | 
14 | [*.{yml,yaml}]
15 | indent_size = 2
16 | 
17 | [docker-compose.yml]
18 | indent_size = 4
19 | 


--------------------------------------------------------------------------------
/resources/js/cp.js:
--------------------------------------------------------------------------------
 1 | import CacheTrackerModal from './components/CacheTrackerModal.vue';
 2 | import ClearUtility from "./pages/ClearUtility.vue";
 3 | import { inertia } from '@statamic/cms/api';
 4 | 
 5 | Statamic.booting(() => {
 6 |     Statamic.$components.register('cache-tracker-modal', CacheTrackerModal);
 7 | 
 8 |    inertia.register('CacheTracker/ClearUtility', ClearUtility);
 9 | });
10 | 


--------------------------------------------------------------------------------
/routes/cp.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | use Illuminate\Support\Facades\Route;
 4 | use Thoughtco\StatamicCacheTracker\Http\Controllers;
 5 | 
 6 | Route::name('cache-tracker.')->prefix('cache-tracker')->group(function () {
 7 |     Route::post('tags', [Controllers\GetTagsController::class, '__invoke'])->name('tags');
 8 |     Route::post('urls', [Controllers\GetUrlsController::class, '__invoke'])->name('url');
 9 | });
10 | 


--------------------------------------------------------------------------------
/src/Facades/Tracker.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Thoughtco\StatamicCacheTracker\Facades;
 4 | 
 5 | use Illuminate\Support\Facades\Facade;
 6 | use Thoughtco\StatamicCacheTracker\Tracker\Manager;
 7 | 
 8 | class Tracker extends Facade
 9 | {
10 |     /**
11 |      * {@inheritdoc}
12 |      */
13 |     protected static function getFacadeAccessor()
14 |     {
15 |         return Manager::class;
16 |     }
17 | }
18 | 


--------------------------------------------------------------------------------
/package.json:
--------------------------------------------------------------------------------
 1 | {
 2 |     "dependencies": {
 3 |         "@statamic/cms": "file:./vendor/statamic/cms/resources/dist-package",
 4 |         "axios": "^1.12.2"
 5 |     },
 6 |     "scripts": {
 7 |         "dev": "vite",
 8 |         "build": "vite build",
 9 |         "production": "vite build"
10 |     },
11 |     "devDependencies": {
12 |         "laravel-vite-plugin": "^1.2.0",
13 |         "vite": "^6.3.4"
14 |     }
15 | }
16 | 


--------------------------------------------------------------------------------
/vite.config.js:
--------------------------------------------------------------------------------
 1 | import laravel from 'laravel-vite-plugin'
 2 | import { defineConfig } from 'vite'
 3 | import statamic from '@statamic/cms/vite-plugin';
 4 | 
 5 | export default defineConfig({
 6 |     plugins: [
 7 |         statamic(),
 8 |         laravel({
 9 |             input: [
10 |                 'resources/js/cp.js'
11 |             ],
12 |             refresh: true,
13 |             publicDirectory: 'dist',
14 |             hotFile: 'dist/hot',
15 |         }),
16 |     ],
17 | });
18 | 


--------------------------------------------------------------------------------
/src/Jobs/InvalidateTags.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Thoughtco\StatamicCacheTracker\Jobs;
 4 | 
 5 | use Illuminate\Bus\Queueable;
 6 | use Illuminate\Contracts\Queue\ShouldQueue;
 7 | use Illuminate\Foundation\Bus\Dispatchable;
 8 | use Illuminate\Queue\InteractsWithQueue;
 9 | use Thoughtco\StatamicCacheTracker\Facades\Tracker;
10 | 
11 | class InvalidateTags implements ShouldQueue
12 | {
13 |     use Dispatchable, InteractsWithQueue, Queueable;
14 | 
15 |     public function __construct(public array $tags) {}
16 | 
17 |     public function handle(): void
18 |     {
19 |         Tracker::invalidate($this->tags);
20 |     }
21 | }
22 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | # Statamic Cache Tracker
 2 | 
 3 | > Statamic Cache Tracker keeps a record of what items (entries, assets, terms etc) are used in the output of each page, and clears the cache (full or half) for those pages when an item is saved.
 4 | 
 5 | 
 6 | ## How to Install
 7 | 
 8 | Run the following command from your project root:
 9 | 
10 | ``` bash
11 | composer require thoughtco/statamic-cache-tracker
12 | ```
13 | 
14 | You can also optionally publish the config:
15 | 
16 | ```bash
17 | php artisan vendor:publish --tag=statamic-cache-tracker-config
18 | ```
19 | 
20 | ## Documentation
21 | 
22 | Documentation for this addon is available at [https://www.docs.tc/cache-tracker](https://www.docs.tc/cache-tracker).
23 | 


--------------------------------------------------------------------------------
/src/Http/Controllers/GetTagsController.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Thoughtco\StatamicCacheTracker\Http\Controllers;
 4 | 
 5 | use Statamic\Http\Controllers\Controller;
 6 | use Statamic\Support\Str;
 7 | use Thoughtco\StatamicCacheTracker\Facades\Tracker;
 8 | 
 9 | class GetTagsController extends Controller
10 | {
11 |     public function __invoke(): array
12 |     {
13 |         if (! $url = request()->input('url')) {
14 |             return [];
15 |         }
16 | 
17 |         if (Str::endsWith($url, '/')) {
18 |             $url = Str::beforeLast($url, '/');
19 |         }
20 | 
21 |         if ($data = Tracker::get($url)) {
22 |             return $data['tags'];
23 |         }
24 | 
25 |         return [];
26 |     }
27 | }
28 | 


--------------------------------------------------------------------------------
/phpunit.xml:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="UTF-8"?>
 2 | <phpunit xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" backupGlobals="false" bootstrap="vendor/autoload.php" colors="true" xsi:noNamespaceSchemaLocation="https://schema.phpunit.de/10.4/phpunit.xsd" processIsolation="false" stopOnFailure="false" beStrictAboutTestsThatDoNotTestAnything="false" cacheDirectory=".phpunit.cache">
 3 |   <testsuites>
 4 |     <testsuite name="Test Suite">
 5 |       <directory suffix="Test.php">./tests</directory>
 6 |     </testsuite>
 7 |   </testsuites>
 8 |   <php>
 9 |     <env name="APP_ENV" value="testing"/>
10 |     <env name="CACHE_DRIVER" value="array"/>
11 |     <env name="SESSION_DRIVER" value="array"/>
12 |     <env name="QUEUE_DRIVER" value="sync"/>
13 |     <env name="MAIL_DRIVER" value="array"/>
14 |     <env name="DB_CONNECTION" value="sqlite"/>
15 |     <env name="DB_DATABASE" value=":memory:"/>
16 |   </php>
17 | </phpunit>
18 | 


--------------------------------------------------------------------------------
/src/Http/Controllers/GetUrlsController.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Thoughtco\StatamicCacheTracker\Http\Controllers;
 4 | 
 5 | use Statamic\Contracts\Entries\Entry;
 6 | use Statamic\Contracts\Taxonomies\Term;
 7 | use Statamic\Facades\Data;
 8 | use Statamic\Http\Controllers\Controller;
 9 | use Thoughtco\StatamicCacheTracker\Facades\Tracker;
10 | 
11 | class GetUrlsController extends Controller
12 | {
13 |     public function __invoke(): array
14 |     {
15 |         if (! $url = request()->input('url')) {
16 |             return [];
17 |         }
18 | 
19 |         if (! $item = Data::find($url)) {
20 |             return [];
21 |         }
22 | 
23 |         if ($item instanceof Entry) {
24 |             $item = $item->collectionHandle().':'.$item->id();
25 |         }
26 | 
27 |         if ($item instanceof Term) {
28 |             $item = 'term:'.$item->id();
29 |         }
30 | 
31 |         return collect(Tracker::all())
32 |             ->filter(fn ($tracked) => in_array($item, $tracked['tags']))
33 |             ->all();
34 |     }
35 | }
36 | 


--------------------------------------------------------------------------------
/.github/workflows/tests.yml:
--------------------------------------------------------------------------------
 1 | name: Test Suite
 2 | 
 3 | on:
 4 |   push:
 5 |   pull_request:
 6 | 
 7 | jobs:
 8 |   php_tests:
 9 |     if: "!contains(github.event.head_commit.message, 'changelog')"
10 | 
11 |     runs-on: ${{ matrix.os }}
12 | 
13 |     strategy:
14 |       matrix:
15 |         php: [8.4, 8.3]
16 |         laravel: [12.*]
17 |         statamic: [^6.0]
18 |         os: [ubuntu-latest]
19 | 
20 |     name: ${{ matrix.php }} - ${{ matrix.statamic }} - ${{ matrix.laravel }}
21 | 
22 |     steps:
23 |       - name: Checkout code
24 |         uses: actions/checkout@v1
25 | 
26 |       - name: Setup PHP
27 |         uses: shivammathur/setup-php@v2
28 |         with:
29 |           php-version: ${{ matrix.php }}
30 |           extensions: dom, curl, libxml, mbstring, zip, pcntl, pdo, sqlite, pdo_sqlite, bcmath, soap, intl, gd, exif, iconv, imagick
31 | 
32 |       - name: Install dependencies
33 |         run: |
34 |           composer require "laravel/framework:${{ matrix.laravel }}" "statamic/cms:${{ matrix.statamic }}" --no-interaction --no-update
35 |           composer install --no-interaction
36 | 
37 |       - name: Run Pest
38 |         run: vendor/bin/pest
39 | 


--------------------------------------------------------------------------------
/tests/Unit/AdditionalTrackerTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Thoughtco\StatamicCacheTracker\Tests\Unit;
 4 | 
 5 | use PHPUnit\Framework\Attributes\Test;
 6 | use Thoughtco\StatamicCacheTracker\Facades\Tracker;
 7 | use Thoughtco\StatamicCacheTracker\Tests\TestCase;
 8 | 
 9 | class AdditionalTrackerTest extends TestCase
10 | {
11 |     #[Test]
12 |     public function tracks_additional_closures()
13 |     {
14 |         Tracker::addAdditionalTracker(function ($tracker, $next) {
15 |             $tracker->addContentTag('test::tag');
16 |         });
17 | 
18 |         $this->get('/');
19 | 
20 |         $this->assertSame(['test::tag', 'pages:home'], collect(Tracker::all())->firstWhere('url', 'http://localhost')['tags']);
21 |     }
22 | 
23 |     #[Test]
24 |     public function tracks_additional_classes()
25 |     {
26 |         Tracker::addAdditionalTracker(AdditionalTrackerClass::class);
27 | 
28 |         $this->get('/');
29 | 
30 |         $this->assertSame(['additional::tag', 'pages:home'], collect(Tracker::all())->firstWhere('url', 'http://localhost')['tags']);
31 |     }
32 | }
33 | 
34 | class AdditionalTrackerClass
35 | {
36 |     public function __invoke($tracker, $next)
37 |     {
38 |         $tracker->addContentTag('additional::tag');
39 |     }
40 | }
41 | 


--------------------------------------------------------------------------------
/resources/js/pages/ClearUtility.vue:
--------------------------------------------------------------------------------
 1 | <script setup>
 2 | import axios from 'axios';
 3 | import { ref } from 'vue';
 4 | 
 5 | const urls = ref('');
 6 | 
 7 | const clearCache = async () => {
 8 |     let response = await axios.post(cp_url('utilities/static-cache-tracker/clear'), { urls: urls.value });
 9 | 
10 |     Statamic.$toast.success(response.data.message);
11 | }
12 | 
13 | </script>
14 | 
15 | <template>
16 |     <ui-header :title="__('Cache Tracker')" icon="taxonomies">
17 |         <ui-button class="btn-primary" v-text="__('Clear everything')" @click="urls = '*'; clearCache();" />
18 |     </ui-header>
19 | 
20 |     <ui-panel class="h-full flex flex-col">
21 |         <ui-panel-header class="flex items-center justify-between min-h-10">
22 |             <ui-heading>{{ __('Enter URLs to clear, with each on a new line. You can use * as a wildcard at the end of your URL.') }}</ui-heading>
23 |         </ui-panel-header>
24 | 
25 |         <ui-card class="flex-1">
26 | 
27 |             <ui-field>
28 |                 <ui-textarea label="Enter URLs" v-model="urls" />
29 |             </ui-field>
30 | 
31 |             <ui-field class="mt-4 flex justify-end">
32 |                 <ui-button variant="primary" v-text="__('Clear')" @click="clearCache" />
33 |             </ui-field>
34 | 
35 |         </ui-card>
36 |     </ui-panel>
37 | 
38 | </template>
39 | 


--------------------------------------------------------------------------------
/src/Actions/ClearCache.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Thoughtco\StatamicCacheTracker\Actions;
 4 | 
 5 | use Statamic\Actions\Action;
 6 | use Statamic\Contracts\Entries\Entry;
 7 | use Statamic\Contracts\Taxonomies\Term;
 8 | use Statamic\Facades\Blink;
 9 | use Thoughtco\StatamicCacheTracker\Facades\Tracker;
10 | 
11 | class ClearCache extends Action
12 | {
13 |     public function run($items, $values)
14 |     {
15 |         $items->filter(fn ($item) => $item->absoluteUrl())
16 |             ->each(fn ($item) => Tracker::remove($item->absoluteUrl()));
17 | 
18 |         return __('Cache cleared');
19 |     }
20 | 
21 |     public function icon(): string
22 |     {
23 |         return 'rewind';
24 |     }
25 | 
26 |     public static function title()
27 |     {
28 |         return __('Clear cache');
29 |     }
30 | 
31 |     public function confirmationText()
32 |     {
33 |         return __('Are you sure you want to clear the static cache for the url: :url ?', ['url' => $this->items->first()->absoluteUrl()]);
34 |     }
35 | 
36 |     public function visibleTo($item)
37 |     {
38 |         if (! auth()->user()->can('clear cache tracker tags')) {
39 |             return false;
40 |         }
41 | 
42 |         if (! ($item instanceof Entry || $item instanceof Term)) {
43 |             return false;
44 |         }
45 | 
46 |         return ! Blink::once(
47 |             'cache-action::'.$item->collectionHandle.'::'.$item->locale(),
48 |             fn () => is_null($item->collection()->route($item->locale()))
49 |         );
50 |     }
51 | }
52 | 


--------------------------------------------------------------------------------
/.github/workflows/release.yaml:
--------------------------------------------------------------------------------
 1 | name: Bundle Release Assets
 2 | 
 3 | on:
 4 |   workflow_dispatch:
 5 |   release:
 6 |     types:
 7 |       - released
 8 |       - prereleased
 9 | 
10 | jobs:
11 |   build:
12 |     runs-on: ubuntu-latest
13 |     steps:
14 |       - name: Checkout code
15 |         uses: actions/checkout@v4
16 | 
17 |       - name: Setup PHP
18 |         uses: shivammathur/setup-php@v2
19 |         with:
20 |           php-version: 8.4
21 |           tools: composer:v2
22 | 
23 |       - name: Use Node.js 23.3.0
24 |         uses: actions/setup-node@v4
25 |         with:
26 |           node-version: 23.3.0
27 | 
28 |       - name: Install composer dependencies
29 |         run: composer install --no-interaction --prefer-dist --optimize-autoloader
30 | 
31 |       - name: Install node dependencies
32 |         run: npm i
33 | 
34 |       - name: Build release assets
35 |         run: npm run build
36 | 
37 |       - name: Create zip
38 |         run: tar -czvf dist.tar.gz dist
39 | 
40 |       - name: Get release
41 |         id: get_release
42 |         uses: cardinalby/git-get-release-action@v1
43 |         env:
44 |           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
45 | 
46 |       - name: Upload dist zip to release
47 |         uses: actions/upload-release-asset@v1.0.1
48 |         env:
49 |           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
50 |         with:
51 |           upload_url: ${{ steps.get_release.outputs.upload_url }}
52 |           asset_path: ./dist.tar.gz
53 |           asset_name: dist.tar.gz
54 |           asset_content_type: application/tar+gz
55 | 


--------------------------------------------------------------------------------
/tests/TestCase.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Thoughtco\StatamicCacheTracker\Tests;
 4 | 
 5 | use Illuminate\Encryption\Encrypter;
 6 | use Statamic\Facades;
 7 | use Statamic\Testing\AddonTestCase;
 8 | use Statamic\Testing\Concerns\PreventsSavingStacheItemsToDisk;
 9 | use Thoughtco\StatamicCacheTracker\ServiceProvider;
10 | 
11 | class TestCase extends AddonTestCase
12 | {
13 |     use PreventsSavingStacheItemsToDisk;
14 | 
15 |     protected string $addonServiceProvider = ServiceProvider::class;
16 | 
17 |     protected $shouldFakeVersion = true;
18 | 
19 |     protected function resolveApplicationConfiguration($app)
20 |     {
21 |         parent::resolveApplicationConfiguration($app);
22 | 
23 |         $app['config']->set('app.key', 'base64:'.base64_encode(Encrypter::generateKey($app['config']['app.cipher'])));
24 | 
25 |         // Assume the pro edition within tests
26 |         $app['config']->set('statamic.editions.pro', true);
27 | 
28 |         // enable caching
29 |         $app['config']->set('statamic.static_caching.strategy', 'half');
30 | 
31 |         // views for front end routing tests
32 |         $app['config']->set('view.paths', [
33 |             __DIR__.'/__fixtures__/resources/views',
34 |         ]);
35 |     }
36 | 
37 |     protected function setUp(): void
38 |     {
39 |         parent::setUp();
40 | 
41 |         Facades\Collection::make('pages')
42 |             ->title('Pages')
43 |             ->routes('{parent_uri}/{slug}')
44 |             ->save();
45 | 
46 |         Facades\Entry::make()
47 |             ->id('home')
48 |             ->collection('pages')
49 |             ->save();
50 |     }
51 | }
52 | 


--------------------------------------------------------------------------------
/composer.json:
--------------------------------------------------------------------------------
 1 | {
 2 |     "name": "thoughtco/statamic-cache-tracker",
 3 |     "autoload": {
 4 |         "psr-4": {
 5 |             "Thoughtco\\StatamicCacheTracker\\": "src"
 6 |         }
 7 |     },
 8 |     "autoload-dev": {
 9 |         "psr-4": {
10 |             "Thoughtco\\StatamicCacheTracker\\Tests\\": "tests"
11 |         }
12 |     },
13 |     "require": {
14 |         "php": "^8.3",
15 |         "pixelfear/composer-dist-plugin": "^0.1.6",
16 |         "statamic/cms": "^6.0"
17 |     },
18 |     "require-dev": {
19 |         "laravel/pint": "^1.13",
20 |         "mockery/mockery": "^1.3.1",
21 |         "nunomaduro/collision": "^8.0",
22 |         "orchestra/testbench": "^10.0",
23 |         "pestphp/pest": "^4.0",
24 |         "phpunit/phpunit": "^12.0"
25 |     },
26 |     "extra": {
27 |         "download-dist": [
28 |             {
29 |                 "url": "https://github.com/thoughtco/statamic-cache-tracker/releases/download/{$version}/dist.tar.gz",
30 |                 "path": "dist"
31 |             }
32 |         ],
33 |         "statamic": {
34 |             "name": "Statamic Cache Tracker",
35 |             "description": "Keep a record of what items are used on each page and invalidate those pages when they are saved."
36 |         },
37 |         "laravel": {
38 |             "providers": [
39 |                 "Thoughtco\\StatamicCacheTracker\\ServiceProvider"
40 |             ]
41 |         }
42 |     },
43 |     "config": {
44 |         "allow-plugins": {
45 |             "pestphp/pest-plugin": true,
46 |             "pixelfear/composer-dist-plugin": true
47 |         }
48 |     },
49 |     "minimum-stability": "alpha"
50 | }
51 | 


--------------------------------------------------------------------------------
/src/Actions/ViewCacheTags.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Thoughtco\StatamicCacheTracker\Actions;
 4 | 
 5 | use Statamic\Actions\Action;
 6 | use Statamic\Contracts\Entries\Entry;
 7 | use Statamic\Facades\Blink;
 8 | 
 9 | class ViewCacheTags extends Action
10 | {
11 |     protected $component = 'cache-tracker-modal';
12 | 
13 |     protected $runnable = false;
14 | 
15 |     public function run($items, $values)
16 |     {
17 |         // no running in the corridor
18 |     }
19 | 
20 |     public function icon(): string
21 |     {
22 |         return 'taxonomies';
23 |     }
24 | 
25 |     public static function title()
26 |     {
27 |         return __('View cache tags');
28 |     }
29 | 
30 |     public function visibleTo($item)
31 |     {
32 |         if (! auth()->user()->can('view cache tracker tags')) {
33 |             return false;
34 |         }
35 | 
36 |         if (! $item instanceof Entry) {
37 |             return false;
38 |         }
39 | 
40 |         return ! Blink::once(
41 |             'cache-action::'.$item->collectionHandle.'::'.$item->locale(),
42 |             fn () => is_null($item->collection()->route($item->locale()))
43 |         );
44 |     }
45 | 
46 |     public function visibleToBulk($items)
47 |     {
48 |         return false;
49 |     }
50 | 
51 |     public function buttonText()
52 |     {
53 |         /** @translation */
54 |         return __('Clear cache');
55 |     }
56 | 
57 |     public function toArray()
58 |     {
59 |         return [
60 |             ...parent::toArray(),
61 |             'item_title' => $this->items->first()?->title,
62 |             'item_url' => $this->items->first()?->absoluteUrl(),
63 |         ];
64 |     }
65 | }
66 | 


--------------------------------------------------------------------------------
/tests/Unit/EventListenerTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Thoughtco\StatamicCacheTracker\Tests\Unit;
 4 | 
 5 | use Illuminate\Http\Request;
 6 | use PHPUnit\Framework\Attributes\Test;
 7 | use Thoughtco\StatamicCacheTracker\Events\TrackContentTags;
 8 | use Thoughtco\StatamicCacheTracker\Facades\Tracker;
 9 | use Thoughtco\StatamicCacheTracker\Http\Middleware\CacheTracker;
10 | use Thoughtco\StatamicCacheTracker\Jobs\InvalidateTags;
11 | use Thoughtco\StatamicCacheTracker\Tests\TestCase;
12 | 
13 | class EventListenerTest extends TestCase
14 | {
15 |     #[Test]
16 |     public function it_tracks_tags_from_events()
17 |     {
18 |         $request = Request::create('/');
19 | 
20 |         $next = function () {
21 |             TrackContentTags::dispatch(['test::tag']);
22 | 
23 |             return response('');
24 |         };
25 | 
26 |         $middleware = new CacheTracker();
27 |         $middleware->handle($request, $next);
28 | 
29 |         $this->assertSame(['test::tag'], collect(Tracker::all())->firstWhere('url', 'http://localhost')['tags']);
30 |     }
31 | 
32 |     #[Test]
33 |     public function dispatching_job_clears_tags()
34 |     {
35 |         $request = Request::create('/');
36 | 
37 |         $next = function () {
38 |             TrackContentTags::dispatch(['test::tag']);
39 | 
40 |             return response('');
41 |         };
42 | 
43 |         $middleware = new CacheTracker();
44 |         $middleware->handle($request, $next);
45 | 
46 |         $this->assertSame(['test::tag'], collect(Tracker::all())->firstWhere('url', 'http://localhost')['tags']);
47 | 
48 |         InvalidateTags::dispatch(['test::tag']);
49 | 
50 |         $this->assertSame([], Tracker::all());
51 |     }
52 | }
53 | 


--------------------------------------------------------------------------------
/src/Http/Controllers/UtilityController.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Thoughtco\StatamicCacheTracker\Http\Controllers;
 4 | 
 5 | use Statamic\Http\Controllers\Controller;
 6 | use Statamic\Support\Str;
 7 | use Thoughtco\StatamicCacheTracker\Facades\Tracker;
 8 | 
 9 | class UtilityController extends Controller
10 | {
11 |     public function __invoke(): array
12 |     {
13 |         if (! $urls = request()->input('urls')) {
14 |             return [
15 |                 'message' => __('No URLs provided'),
16 |             ];
17 |         }
18 | 
19 |         if ($urls == '*') {
20 |             Tracker::flush();
21 | 
22 |             return [
23 |                 'message' => __('Cache flushed'),
24 |             ];
25 |         }
26 | 
27 |         $urls = collect(explode(PHP_EOL, $urls));
28 | 
29 |         $wildcards = $urls->filter(fn ($url) => Str::endsWith($url, '*'));
30 | 
31 |         // remove any non-wildcards first
32 |         $urls->reject(fn ($url) => Str::endsWith($url, '*'))
33 |             ->each(function ($url) {
34 |                 if (Str::endsWith($url, '/')) {
35 |                     $url = substr($url, 0, -1);
36 |                 }
37 | 
38 |                 Tracker::remove($url);
39 |             });
40 | 
41 |         collect(Tracker::all())
42 |             ->each(function ($data) use ($wildcards) {
43 |                 $wildcards->each(function ($wildcard) use ($data) {
44 |                     if (Str::startsWith($data['url'], Str::beforeLast($wildcard, '*'))) {
45 |                         Tracker::remove($data['url']);
46 |                     }
47 |                 });
48 |             });
49 | 
50 |         return [
51 |             'message' => __('URLs cleared from cache'),
52 |         ];
53 |     }
54 | }
55 | 


--------------------------------------------------------------------------------
/src/ServiceProvider.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Thoughtco\StatamicCacheTracker;
 4 | 
 5 | use Statamic\Facades\Permission;
 6 | use Statamic\Facades\Utility;
 7 | use Statamic\Providers\AddonServiceProvider;
 8 | use Thoughtco\StatamicCacheTracker\Http\Controllers\UtilityController;
 9 | 
10 | class ServiceProvider extends AddonServiceProvider
11 | {
12 |     protected $actions = [
13 |         Actions\ClearCache::class,
14 |         Actions\ViewCacheTags::class,
15 |     ];
16 | 
17 |     protected $middlewareGroups = [
18 |         'web' => [
19 |             Http\Middleware\CacheTracker::class,
20 |         ],
21 |     ];
22 | 
23 |     protected $subscribe = [
24 |         Listeners\Subscriber::class,
25 |     ];
26 | 
27 |     protected $routes = [
28 |         'cp' => __DIR__.'/../routes/cp.php',
29 |     ];
30 | 
31 |     protected $vite = [
32 |         'input' => ['resources/js/cp.js'],
33 |         'publicDirectory' => 'dist',
34 |         'hotFile' => __DIR__.'/../dist/hot',
35 |     ];
36 | 
37 |     public function boot()
38 |     {
39 |         parent::boot();
40 | 
41 |         $this->mergeConfigFrom($config = __DIR__.'/../config/statamic-cache-tracker.php', 'statamic-cache-tracker');
42 | 
43 |         $this->publishes([
44 |             $config => config_path('statamic-cache-tracker.php'),
45 |         ], 'statamic-cache-tracker-config');
46 | 
47 |         $this->setupAddonPermissions()
48 |             ->setupAddonUtility();
49 |     }
50 | 
51 |     private function setupAddonPermissions()
52 |     {
53 |         Permission::group('cache-tracker', 'Cache Tracker', function () {
54 |             Permission::register('view cache tracker tags')
55 |                 ->label(__('View Tags'))
56 |                 ->description(__('Enable the action on listing views to view tags'));
57 | 
58 |             Permission::register('clear cache tracker tags')
59 |                 ->label(__('Clear Tags'))
60 |                 ->description(__('Enable the action on listing views to clear tags'));
61 |         });
62 | 
63 |         return $this;
64 |     }
65 | 
66 |     private function setupAddonUtility()
67 |     {
68 |         Utility::extend(function () {
69 |             Utility::register('static-cache-tracker')
70 |                 ->title(__('Cache Tracker'))
71 |                 ->description(__('Clear specific paths in your static cache.'))
72 |                 ->inertia('CacheTracker/ClearUtility')
73 |                 ->icon('taxonomies')
74 |                 ->routes(function ($router) {
75 |                     $router->post('/clear', UtilityController::class)->name('clear');
76 |                 });
77 |         });
78 | 
79 |         return $this;
80 |     }
81 | }
82 | 


--------------------------------------------------------------------------------
/tests/Unit/TrackerTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Thoughtco\StatamicCacheTracker\Tests\Unit;
 4 | 
 5 | use Illuminate\Support\Facades\Event;
 6 | use PHPUnit\Framework\Attributes\Test;
 7 | use Statamic\Events\UrlInvalidated;
 8 | use Thoughtco\StatamicCacheTracker\Events\ContentTracked;
 9 | use Thoughtco\StatamicCacheTracker\Facades\Tracker;
10 | use Thoughtco\StatamicCacheTracker\Tests\TestCase;
11 | 
12 | class TrackerTest extends TestCase
13 | {
14 |     #[Test]
15 |     public function it_tracks_uncached_pages()
16 |     {
17 |         Event::fake();
18 | 
19 |         Tracker::addAdditionalTracker(function ($tracker, $next) {
20 |             $tracker->addContentTag('test::tag');
21 |         });
22 | 
23 |         $this->get('/');
24 | 
25 |         $this->assertSame(['test::tag', 'pages:home'], collect(Tracker::all())->first()['tags']);
26 | 
27 |         Event::assertDispatched(ContentTracked::class, 1);
28 |     }
29 | 
30 |     #[Test]
31 |     public function it_doesnt_track_already_cached_pages()
32 |     {
33 |         Event::fake();
34 | 
35 |         Tracker::addAdditionalTracker(function ($tracker, $next) {
36 |             $tracker->addContentTag('test::tag');
37 |         });
38 | 
39 |         $this->get('/');
40 | 
41 |         $this->assertSame(['test::tag', 'pages:home'], collect(Tracker::all())->first()['tags']);
42 | 
43 |         $this->get('/');
44 | 
45 |         $this->assertSame(['test::tag', 'pages:home'], collect(Tracker::all())->first()['tags']);
46 | 
47 |         Event::assertDispatched(ContentTracked::class, 1);
48 |     }
49 | 
50 |     #[Test]
51 |     public function it_doesnt_track_pages_already_in_the_manifest()
52 |     {
53 |         Event::fake();
54 | 
55 |         Tracker::add('/', ['some:thing']);
56 | 
57 |         Tracker::addAdditionalTracker(function ($tracker, $next) {
58 |             $tracker->addContentTag('test::tag');
59 |         });
60 | 
61 |         $this->get('/');
62 | 
63 |         $this->assertSame(['some:thing'], collect(Tracker::all())->first()['tags']);
64 |     }
65 | 
66 |     #[Test]
67 |     public function it_doesnt_track_404_pages()
68 |     {
69 |         $this->get('/i-dont-exist');
70 | 
71 |         $this->assertCount(0, Tracker::all());
72 |     }
73 | 
74 |     #[Test]
75 |     public function it_flushes()
76 |     {
77 |         Event::fake();
78 | 
79 |         Tracker::addAdditionalTracker(function ($tracker, $next) {
80 |             $tracker->addContentTag('test::tag');
81 |         });
82 | 
83 |         $this->get('/');
84 | 
85 |         $this->assertSame(['test::tag', 'pages:home'], collect(Tracker::all())->first()['tags']);
86 | 
87 |         $this->assertCount(1, Tracker::all());
88 | 
89 |         Tracker::flush();
90 | 
91 |         $this->assertCount(0, Tracker::all());
92 |         Event::assertDispatched(UrlInvalidated::class);
93 |     }
94 | }
95 | 


--------------------------------------------------------------------------------
/resources/js/components/CacheTrackerModal.vue:
--------------------------------------------------------------------------------
 1 | <script setup>
 2 | import axios from 'axios';
 3 | import { ref } from 'vue';
 4 | 
 5 | const props = defineProps({
 6 |     action: { type: Object, required: true },
 7 | });
 8 | 
 9 | const getColor = (tag) => {
10 |     if (tag.indexOf('collection:') === 0) {
11 |         return 'yellow';
12 |     }
13 | 
14 |     if (tag.indexOf('term:') === 0) {
15 |         return 'rose';
16 |     }
17 | 
18 |     if (tag.indexOf('global:') === 0) {
19 |         return 'violet';
20 |     }
21 | 
22 |     if (tag.indexOf('partial:') === 0) {
23 |         return 'blue';
24 |     }
25 | 
26 |     return 'green';
27 | }
28 | 
29 | const setShowWhat = (what) => {
30 |     show.value = what;
31 | }
32 | 
33 | const item = props.action?.item_title ?? '';
34 | const url = props.action?.item_url ?? '';
35 | const show = ref('tags');
36 | const tags = ref([]);
37 | const urls = ref([]);
38 | 
39 | axios
40 |     .post(cp_url(`/cache-tracker/tags`), { url: url })
41 |     .then(response => {
42 |         tags.value = response.data;
43 |     })
44 |     .catch((e) => { });
45 | 
46 | axios
47 |     .post(cp_url(`/cache-tracker/urls`), { url: url })
48 |     .then(response => {
49 |         urls.value = response.data;
50 |     })
51 |     .catch((e) => { });
52 | </script>
53 | 
54 | <template>
55 |     <div>
56 |         <ui-button-group class="mb-4">
57 |             <ui-button :variant="show == 'tags' ? 'primary' : 'default'" size="sm" @click="setShowWhat('tags')">Tags on this URL</ui-button>
58 |             <ui-button :variant="show == 'urls' ? 'primary' : 'default'"  size="sm" @click="setShowWhat('urls')">URLs with this item</ui-button>
59 |         </ui-button-group>
60 | 
61 |         <div v-if="show == 'tags'">
62 | 
63 |             <ui-description v-text="__('There are no tags tracked on :url.', { url: url })" v-if="tags.length < 1"></ui-description>
64 | 
65 |             <ui-description v-text="__('The following tags are being tracked on :url:', { url: url })" v-if="tags.length"></ui-description>
66 | 
67 |             <div class="flex gap-2 mt-4" v-if="tags.length">
68 | 
69 |                 <template v-for="tag in tags">
70 |                     <ui-badge pill :color="getColor(tag)" v-text="tag"></ui-badge>
71 |                 </template>
72 | 
73 |             </div>
74 | 
75 |         </div>
76 | 
77 |         <div v-if="show == 'urls'">
78 |             <ui-description v-text="__('There are no urls tracked containing :item.', { item: item })" v-if="urls.length < 1"></ui-description>
79 | 
80 |             <ui-description v-text="__('The following URLs contain :item:', { item: 'ryan' })" v-if="urls.length"></ui-description>
81 | 
82 |             <div class="flex gap-2 mt-4" v-if="urls.length">
83 | 
84 |                 <template v-for="url in urls">
85 |                     <a :href="url" v-text="url"></a><br />
86 |                 </template>
87 | 
88 |             </div>
89 | 
90 |         </div>
91 |     </div>
92 | </template>
93 | 


--------------------------------------------------------------------------------
/src/Tracker/Manager.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | namespace Thoughtco\StatamicCacheTracker\Tracker;
  4 | 
  5 | use Closure;
  6 | use Illuminate\Support\Arr;
  7 | use Illuminate\Support\Facades\Cache;
  8 | use InvalidArgumentException;
  9 | use Statamic\StaticCaching\Cacher;
 10 | use Thoughtco\StatamicCacheTracker\Events\ContentTracked;
 11 | 
 12 | class Manager
 13 | {
 14 |     private string $cacheKey = 'tracker::urls';
 15 | 
 16 |     private array $pipelines = [];
 17 | 
 18 |     public function add(string $url, array $tags = [])
 19 |     {
 20 |         $storeData = $this->all();
 21 |         $storeData[md5($url)] = [
 22 |             'url' => $url,
 23 |             'tags' => collect($tags)->unique()->values()->all(),
 24 |         ];
 25 | 
 26 |         $this->cacheStore()->forever($this->cacheKey, $storeData);
 27 | 
 28 |         ContentTracked::dispatch($url, $tags);
 29 | 
 30 |         return $this;
 31 |     }
 32 | 
 33 |     public function addAdditionalTracker(Closure|string $class)
 34 |     {
 35 |         if (is_string($class)) {
 36 |             $class = new $class;
 37 |         }
 38 | 
 39 |         $this->pipelines[] = $class;
 40 | 
 41 |         return $this;
 42 |     }
 43 | 
 44 |     public function all()
 45 |     {
 46 |         return $this->cacheStore()->get($this->cacheKey) ?? [];
 47 |     }
 48 | 
 49 |     public function cacheStore()
 50 |     {
 51 |         try {
 52 |             $store = Cache::store('static_cache');
 53 |         } catch (InvalidArgumentException $e) {
 54 |             $store = Cache::store();
 55 |         }
 56 | 
 57 |         return $store;
 58 |     }
 59 | 
 60 |     public function get(string $url)
 61 |     {
 62 |         return $this->all()[md5($url)] ?? null;
 63 |     }
 64 | 
 65 |     public function getAdditionalTrackers()
 66 |     {
 67 |         return $this->pipelines;
 68 |     }
 69 | 
 70 |     public function has(string $url)
 71 |     {
 72 |         return Arr::exists($this->all(), md5($url));
 73 |     }
 74 | 
 75 |     public function invalidate(array $tags = [])
 76 |     {
 77 |         $storeData = $this->all();
 78 | 
 79 |         $urls = [];
 80 |         foreach ($storeData as $key => $data) {
 81 |             $storeTags = $data['tags'];
 82 |             $url = $data['url'];
 83 | 
 84 |             if (count(array_intersect($tags, $storeTags)) > 0) {
 85 |                 $urls[] = $url;
 86 | 
 87 |                 unset($storeData[$key]);
 88 |             }
 89 |         }
 90 | 
 91 |         if (! empty($urls)) {
 92 |             $this->cacheStore()->forever($this->cacheKey, $storeData);
 93 | 
 94 |             $this->invalidateUrls($urls);
 95 |         }
 96 | 
 97 |         return $this;
 98 |     }
 99 | 
100 |     private function invalidateUrls($urls)
101 |     {
102 |         $cacher = app(Cacher::class);
103 |         $cacher->invalidateUrls($urls);
104 |     }
105 | 
106 |     public function flush()
107 |     {
108 |         $urls = collect($this->all())->pluck('url');
109 | 
110 |         $this->invalidateUrls($urls);
111 | 
112 |         $this->cacheStore()->forever($this->cacheKey, []);
113 |     }
114 | 
115 |     public function remove(string $url)
116 |     {
117 |         $this->invalidateUrls([$url]);
118 | 
119 |         $this->cacheStore()->forget(md5($url));
120 |     }
121 | }
122 | 


--------------------------------------------------------------------------------
/src/Listeners/Subscriber.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | namespace Thoughtco\StatamicCacheTracker\Listeners;
  4 | 
  5 | use Statamic\Events;
  6 | use Thoughtco\StatamicCacheTracker\Facades\Tracker;
  7 | use Thoughtco\StatamicCacheTracker\Jobs\InvalidateTags;
  8 | 
  9 | class Subscriber
 10 | {
 11 |     protected $events = [
 12 |         Events\AssetDeleted::class => 'invalidateAsset',
 13 |         Events\AssetSaved::class => 'invalidateAsset',
 14 | 
 15 |         Events\EntryDeleted::class => 'invalidateAndDeleteEntry',
 16 |         Events\EntrySaved::class => 'invalidateEntry',
 17 | 
 18 |         Events\FormDeleted::class => 'invalidateForm',
 19 |         Events\FormSaved::class => 'invalidateForm',
 20 | 
 21 |         Events\GlobalSetDeleted::class => 'invalidateGlobal',
 22 |         Events\GlobalVariablesSaved::class => 'invalidateGlobal',
 23 | 
 24 |         Events\NavDeleted::class => 'invalidateNav',
 25 |         Events\NavTreeSaved::class => 'invalidateNav',
 26 |         Events\CollectionTreeSaved::class => 'invalidateNav',
 27 | 
 28 |         Events\TermDeleted::class => 'invalidateAndDeleteTerm',
 29 |         Events\TermSaved::class => 'invalidateTerm',
 30 |     ];
 31 | 
 32 |     public function subscribe($dispatcher): void
 33 |     {
 34 |         foreach ($this->events as $event => $method) {
 35 |             if (class_exists($event)) {
 36 |                 $dispatcher->listen($event, [self::class, $method]);
 37 |             }
 38 |         }
 39 |     }
 40 | 
 41 |     public function invalidateAsset($event)
 42 |     {
 43 |         $tags = [
 44 |             'asset:'.$event->asset->id(),
 45 |         ];
 46 | 
 47 |         $this->invalidateContent($tags);
 48 |     }
 49 | 
 50 |     public function invalidateEntry($event)
 51 |     {
 52 |         $entry = $event->entry;
 53 | 
 54 |         $collectionHandle = strtolower($entry->collection()->handle());
 55 | 
 56 |         $tags = [
 57 |             $collectionHandle.':'.$entry->id(),
 58 |         ];
 59 | 
 60 |         $this->invalidateContent($tags);
 61 |     }
 62 | 
 63 |     public function invalidateAndDeleteEntry($event)
 64 |     {
 65 |         $this->invalidateEntry($event);
 66 | 
 67 |         if ($url = $event->entry->absoluteUrl()) {
 68 |             Tracker::remove($url);
 69 |         }
 70 |     }
 71 | 
 72 |     public function invalidateForm($event)
 73 |     {
 74 |         $tags = [
 75 |             'form:'.$event->form->handle(),
 76 |         ];
 77 | 
 78 |         $this->invalidateContent($tags);
 79 |     }
 80 | 
 81 |     public function invalidateGlobal($event)
 82 |     {
 83 |         $tags = [
 84 |             'global:'.($event->globals ?? $event->variables->globalSet())->handle(),
 85 |         ];
 86 | 
 87 |         $this->invalidateContent($tags);
 88 |     }
 89 | 
 90 |     public function invalidateNav($event)
 91 |     {
 92 |         $tags = [
 93 |             'nav:'.($event->nav ?? $event->tree)->handle(),
 94 |         ];
 95 | 
 96 |         $this->invalidateContent($tags);
 97 |     }
 98 | 
 99 |     public function invalidateTerm($event)
100 |     {
101 |         $tags = [
102 |             'term:'.$event->term->id(),
103 |         ];
104 | 
105 |         $this->invalidateContent($tags);
106 |     }
107 | 
108 |     public function invalidateAndDeleteTerm($event)
109 |     {
110 |         $this->invalidateTerm($event);
111 | 
112 |         if ($url = $event->term->absoluteUrl()) {
113 |             Tracker::remove($url);
114 |         }
115 |     }
116 | 
117 |     private function invalidateContent($tags)
118 |     {
119 |         InvalidateTags::dispatch($tags);
120 |     }
121 | }
122 | 


--------------------------------------------------------------------------------
/src/Http/Middleware/CacheTracker.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | namespace Thoughtco\StatamicCacheTracker\Http\Middleware;
  4 | 
  5 | use Closure;
  6 | use Illuminate\Pipeline\Pipeline;
  7 | use Illuminate\Support\Arr;
  8 | use Illuminate\Support\Facades\Event;
  9 | use Livewire\Livewire;
 10 | use Statamic\Contracts\Assets\Asset;
 11 | use Statamic\Contracts\Entries\Entry;
 12 | use Statamic\Contracts\Globals\Variables;
 13 | use Statamic\Facades\URL;
 14 | use Statamic\Forms;
 15 | use Statamic\StaticCaching\Cacher;
 16 | use Statamic\Structures\Page;
 17 | use Statamic\Support\Str;
 18 | use Statamic\Tags;
 19 | use Statamic\Taxonomies\LocalizedTerm;
 20 | use Thoughtco\StatamicCacheTracker\Events\TrackContentTags;
 21 | use Thoughtco\StatamicCacheTracker\Facades\Tracker;
 22 | 
 23 | class CacheTracker
 24 | {
 25 |     private array $content = [];
 26 | 
 27 |     public function addContentTag($tag)
 28 |     {
 29 |         $tags = Arr::wrap($tag);
 30 | 
 31 |         foreach ($tags as $tag) {
 32 |             $this->content[] = $tag;
 33 |         }
 34 | 
 35 |         return $this;
 36 |     }
 37 | 
 38 |     public function handle($request, Closure $next)
 39 |     {
 40 |         if (! $this->isEnabled($request)) {
 41 |             return $next($request);
 42 |         }
 43 | 
 44 |         $cacher = app(Cacher::class);
 45 | 
 46 |         if ($cacher && $cacher->hasCachedPage($request)) {
 47 |             return $next($request);
 48 |         }
 49 | 
 50 |         $url = $this->url();
 51 | 
 52 |         if (Str::endsWith($url, '/')) {
 53 |             $url = substr($url, 0, -1);
 54 |         }
 55 | 
 56 |         if (Tracker::has($url)) {
 57 |             return $next($request);
 58 |         }
 59 | 
 60 |         $this
 61 |             ->setupTagHooks()
 62 |             ->setupAugmentationHooks($url)
 63 |             ->setupAdditionalTracking();
 64 | 
 65 |         Event::listen(function (TrackContentTags $event) {
 66 |             $this->content = array_merge($this->content, $event->tags ?? []);
 67 |         });
 68 | 
 69 |         $response = $next($request);
 70 | 
 71 |         if (method_exists($response, 'status') && $response->status() !== 200) {
 72 |             return $response;
 73 |         }
 74 | 
 75 |         try {
 76 |             if ($response->wasStaticallyCached()) {
 77 |                 return $response;
 78 |             }
 79 |         } catch (\Throwable $e) {
 80 | 
 81 |         }
 82 | 
 83 |         if ($this->content) {
 84 |             Tracker::add($url, array_unique($this->content));
 85 |         }
 86 | 
 87 |         return $response;
 88 |     }
 89 | 
 90 |     private function isEnabled($request)
 91 |     {
 92 |         if (! config('statamic.static_caching.strategy')) {
 93 |             return false;
 94 |         }
 95 | 
 96 |         if (! config('statamic-cache-tracker.enabled', true)) {
 97 |             return false;
 98 |         }
 99 | 
100 |         // Only GET requests. This disables the cache during live preview.
101 |         return $request->method() === 'GET' && ! Str::startsWith($request->path(), [config('statamic.routes.action', '!').'/', config('statamic.assets.image_manipulation.route')]);
102 |     }
103 | 
104 |     private function setupAdditionalTracking()
105 |     {
106 |         $pipelines = Tracker::getAdditionalTrackers();
107 | 
108 |         if (empty($pipelines)) {
109 |             return $this;
110 |         }
111 | 
112 |         (new Pipeline)
113 |             ->send($this)
114 |             ->through($pipelines)
115 |             ->thenReturn();
116 | 
117 |         return $this;
118 |     }
119 | 
120 |     private function setupAugmentationHooks(string $url)
121 |     {
122 |         $self = $this;
123 | 
124 |         app(Asset::class)::hook('augmented', function ($augmented, $next) use ($self) {
125 |             $self->addContentTag('asset:'.$this->id());
126 | 
127 |             return $next($augmented);
128 |         });
129 | 
130 |         app(Entry::class)::hook('augmented', function ($augmented, $next) use ($self) {
131 |             $self->addContentTag($this->collection()->handle().':'.$this->id());
132 | 
133 |             return $next($augmented);
134 |         });
135 | 
136 |         Page::hook('augmented', function ($augmented, $next) use ($self) {
137 |             if ($entry = $this->entry()) {
138 |                 $self->addContentTag($entry->collection()->handle().':'.$entry->id());
139 |             }
140 | 
141 |             return $next($augmented);
142 |         });
143 | 
144 |         LocalizedTerm::hook('augmented', function ($augmented, $next) use ($self) {
145 |             $self->addContentTag('term:'.$this->id());
146 | 
147 |             return $next($augmented);
148 |         });
149 | 
150 |         app(Variables::class)::hook('augmented', function ($augmented, $next) use ($self) {
151 |             $self->addContentTag('global:'.$this->globalSet()->handle());
152 | 
153 |             return $next($augmented);
154 |         });
155 | 
156 |         return $this;
157 |     }
158 | 
159 |     private function setupTagHooks()
160 |     {
161 |         $self = $this;
162 | 
163 |         Forms\Tags::hook('init', function ($value, $next) use ($self) {
164 |             if (in_array($this->method, ['errors', 'success', 'submission'])) {
165 |                 return $next($value);
166 |             }
167 | 
168 |             if ($form = $this->params->get('in')) {
169 |                 $form = is_string($form) ? $form : $form->handle();
170 |                 $self->addContentTag('form:'.$form);
171 | 
172 |                 return $next($value);
173 |             }
174 | 
175 |             $self->addContentTag($this->tag);
176 | 
177 |             return $next($value);
178 |         });
179 | 
180 |         Tags\Nav::hook('init', function ($value, $next) use ($self) {
181 |             $handle = $this->params->get('handle') ? 'nav:'.$this->params->get('handle') : $this->tag;
182 |             $self->addContentTag($handle);
183 | 
184 |             return $next($value);
185 |         });
186 | 
187 |         Tags\Partial::hook('init', function ($value, $next) use ($self) {
188 |             $handle = $this->params->get('src') ?? str_replace('partial:', '', $this->tag);
189 |             $self->addContentTag('partial:'.$handle);
190 | 
191 |             return $next($value);
192 |         });
193 | 
194 |         return $this;
195 |     }
196 | 
197 |     private function url()
198 |     {
199 |         return URL::makeAbsolute(class_exists(Livewire::class) ? Livewire::originalUrl() : URL::getCurrent());
200 |     }
201 | }
202 | 


--------------------------------------------------------------------------------