Exclude sections from static caching (nocache tag)

config/static_caching.php

@@ -98,4 +98,19 @@
 
     'ignore_query_strings' => false,
 
+    /*
+    |--------------------------------------------------------------------------
+    | Replacers
+    |--------------------------------------------------------------------------
+    |
+    | Here you may define replacers that dynamically replace content within
+    | the response. Each replacer must implement the Replacer interface.
+    |
+    */
+
+    'replacers' => [
+        \Statamic\StaticCaching\Replacers\CsrfTokenReplacer::class,
+        \Statamic\StaticCaching\Replacers\NoCacheReplacer::class,
+    ],
+
 ];

routes/web.php

@@ -48,6 +48,10 @@
         Statamic::additionalActionRoutes();
     });
 
+    Route::prefix(config('statamic.routes.action'))
+        ->post('nocache', '\Statamic\StaticCaching\NoCache\Controller')
+        ->withoutMiddleware('App\Http\Middleware\VerifyCsrfToken');
+
     if (OAuth::enabled()) {
         Route::get(config('statamic.oauth.routes.login'), 'OAuthController@redirectToProvider')->name('oauth.login');
         Route::get(config('statamic.oauth.routes.callback'), 'OAuthController@handleProviderCallback')->name('oauth.callback');

src/Console/Commands/StaticClear.php

@@ -4,7 +4,7 @@
 
 use Illuminate\Console\Command;
 use Statamic\Console\RunsInPlease;
-use Statamic\StaticCaching\Cacher as StaticCacher;
+use Statamic\Facades\StaticCache;
 
 class StaticClear extends Command
 {
@@ -31,7 +31,7 @@ class StaticClear extends Command
      */
     public function handle()
     {
-        app(StaticCacher::class)->flush();
+        StaticCache::flush();
 
         $this->info('Your static page cache is now so very, very empty.');
     }

src/Facades/StaticCache.php

@@ -0,0 +1,17 @@
+<?php
+
+namespace Statamic\Facades;
+
+use Illuminate\Support\Facades\Facade;
+use Statamic\StaticCaching\StaticCacheManager;
+
+/**
+ * @see StaticCacheManager
+ */
+class StaticCache extends Facade
+{
+    protected static function getFacadeAccessor()
+    {
+        return StaticCacheManager::class;
+    }
+}

src/Providers/ExtensionServiceProvider.php

@@ -183,6 +183,7 @@ class ExtensionServiceProvider extends ServiceProvider
         \Statamic\Auth\Protect\Tags::class,
         \Statamic\OAuth\Tags::class,
         \Statamic\Search\Tags::class,
+        \Statamic\StaticCaching\NoCache\Tags::class,
     ];
 
     protected $widgets = [

src/StaticCaching/Cachers/FileCacher.php

@@ -6,6 +6,7 @@
 use Illuminate\Http\Request;
 use Illuminate\Support\Facades\Log;
 use Statamic\Facades\File;
+use Statamic\StaticCaching\Replacers\CsrfTokenReplacer;
 use Statamic\Support\Arr;
 use Statamic\Support\Str;
 
@@ -16,6 +17,21 @@ class FileCacher extends AbstractCacher
      */
     private $writer;
 
+    /**
+     * @var bool
+     */
+    private $shouldOutputJs = false;
+
+    /**
+     * @var string
+     */
+    private $nocacheJs;
+
+    /**
+     * @var string
+     */
+    private $nocachePlaceholder;
+
     /**
      * @param  Writer  $writer
      * @param  Repository  $cache
@@ -166,4 +182,69 @@ private function isLongQueryStringPath($path)
     {
         return Str::contains($path, '_lqs_');
     }
+
+    public function setNocacheJs(string $js)
+    {
+        $this->nocacheJs = $js;
+    }
+
+    public function getNocacheJs(): string
+    {
+        $csrfPlaceholder = CsrfTokenReplacer::REPLACEMENT;
+
+        $default = <<<EOT
+var els = document.getElementsByClassName('nocache');
+var map = {};
+for (var i = 0; i < els.length; i++) {
+    var section = els[i].getAttribute('data-nocache');
+    map[section] = els[i];
+}
+
+fetch('/!/nocache', {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify({
+        url: window.location.href,
+        sections: Object.keys(map)
+    })
+})
+.then((response) => response.json())
+.then((data) => {
+    const regions = data.regions;
+    for (var key in regions) {
+        if (map[key]) map[key].outerHTML = regions[key];
+    }
+
+    for (const input of document.querySelectorAll('input[value=$csrfPlaceholder]')) {
+        input.value = data.csrf;
+    }
+
+    for (const meta of document.querySelectorAll('meta[content=$csrfPlaceholder]')) {
+        meta.content = data.csrf;
+    }
+});
+EOT;
+
+        return $this->nocacheJs ?? $default;
+    }
+
+    public function shouldOutputJs(): bool
+    {
+        return $this->shouldOutputJs;
+    }
+
+    public function includeJs()
+    {
+        $this->shouldOutputJs = true;
+    }
+
+    public function setNocachePlaceholder(string $content)
+    {
+        $this->nocachePlaceholder = $content;
+    }
+
+    public function getNocachePlaceholder()
+    {
+        return $this->nocachePlaceholder ?? '';
+    }
 }

src/StaticCaching/Middleware/Cache.php

@@ -3,8 +3,11 @@
 namespace Statamic\StaticCaching\Middleware;
 
 use Closure;
+use Illuminate\Support\Collection;
 use Statamic\Statamic;
 use Statamic\StaticCaching\Cacher;
+use Statamic\StaticCaching\NoCache\Session;
+use Statamic\StaticCaching\Replacer;
 
 class Cache
 {
@@ -13,9 +16,15 @@ class Cache
      */
     private $cacher;
 
-    public function __construct(Cacher $cacher)
+    /**
+     * @var Session
+     */
+    protected $nocache;
+
+    public function __construct(Cacher $cacher, Session $nocache)
     {
         $this->cacher = $cacher;
+        $this->nocache = $nocache;
     }
 
     /**
@@ -28,18 +37,38 @@ public function __construct(Cacher $cacher)
     public function handle($request, Closure $next)
     {
         if ($this->canBeCached($request) && $this->cacher->hasCachedPage($request)) {
-            return response($this->cacher->getCachedPage($request));
+            $response = response($this->cacher->getCachedPage($request));
+
+            $this->getReplacers()->each(fn (Replacer $replacer) => $replacer->replaceInCachedResponse($response));
+
+            return $response;
         }
 
         $response = $next($request);
 
         if ($this->shouldBeCached($request, $response)) {
-            $this->cacher->cachePage($request, $response);
+            $this->makeReplacementsAndCacheResponse($request, $response);
+
+            $this->nocache->write();
         }
 
         return $response;
     }
 
+    private function makeReplacementsAndCacheResponse($request, $response)
+    {
+        $cachedResponse = clone $response;
+
+        $this->getReplacers()->each(fn (Replacer $replacer) => $replacer->prepareResponseToCache($cachedResponse, $response));
+
+        $this->cacher->cachePage($request, $cachedResponse);
+    }
+
+    private function getReplacers(): Collection
+    {
+        return collect(config('statamic.static_caching.replacers'))->map(fn ($class) => app($class));
+    }
+
     private function canBeCached($request)
     {
         if ($request->method() !== 'GET') {

src/StaticCaching/NoCache/BladeDirective.php

@@ -0,0 +1,23 @@
+<?php
+
+namespace Statamic\StaticCaching\NoCache;
+
+class BladeDirective
+{
+    /**
+     * @var Session
+     */
+    private $nocache;
+
+    public function __construct(Session $nocache)
+    {
+        $this->nocache = $nocache;
+    }
+
+    public function handle($expression, $context)
+    {
+        $view = $expression;
+
+        return $this->nocache->pushView($view, $context)->placeholder();
+    }
+}

src/StaticCaching/NoCache/Controller.php

@@ -0,0 +1,26 @@
+<?php
+
+namespace Statamic\StaticCaching\NoCache;
+
+use Illuminate\Http\Request;
+use Statamic\StaticCaching\Replacers\NoCacheReplacer;
+
+class Controller
+{
+    public function __invoke(Request $request, Session $session)
+    {
+        $url = $request->input('url'); // todo: maybe strip off query params?
+
+        $session = $session->setUrl($url)->restore();
+
+        $replacer = new NoCacheReplacer($session);
+
+        return [
+            'csrf' => csrf_token(),
+            'regions' => $session
+                ->regions()
+                ->map->render()
+                ->map(fn ($contents) => $replacer->replace($contents)),
+        ];
+    }
+}

src/StaticCaching/NoCache/Region.php

@@ -0,0 +1,80 @@
+<?php
+
+namespace Statamic\StaticCaching\NoCache;
+
+use Statamic\Support\Arr;
+
+abstract class Region
+{
+    protected $key;
+    protected $context = [];
+    protected $session;
+
+    public function setSession(Session $session)
+    {
+        $this->session = $session;
+    }
+
+    public function placeholder(): string
+    {
+        return sprintf('<span class="nocache" data-nocache="%s">NOCACHE_PLACEHOLDER</span>', $this->key());
+    }
+
+    public function context(): array
+    {
+        return $this->context;
+    }
+
+    protected function filterContext(array $context)
+    {
+        foreach (['__env', 'app', 'errors'] as $var) {
+            unset($context[$var]);
+        }
+
+        return $this->arrayRecursiveDiff($context, $this->session->cascade());
+    }
+
+    public function fragmentData(): array
+    {
+        return array_merge($this->session->cascade(), $this->context());
+    }
+
+    private function arrayRecursiveDiff($a, $b)
+    {
+        $data = [];
+
+        foreach ($a as $aKey => $aValue) {
+            if (! is_object($aKey) && is_array($b) && array_key_exists($aKey, $b)) {
+                if (is_array($aValue)) {
+                    $aRecursiveDiff = $this->arrayRecursiveDiff($aValue, $b[$aKey]);
+
+                    if (! empty($aRecursiveDiff)) {
+                        $data[$aKey] = $aRecursiveDiff;
+                    }
+                } else {
+                    if ($aValue != $b[$aKey]) {
+                        $data[$aKey] = $aValue;
+                    }
+                }
+            } else {
+                $data[$aKey] = $aValue;
+            }
+        }
+
+        return $data;
+    }
+
+    public function __serialize(): array
+    {
+        return Arr::except(get_object_vars($this), ['session']);
+    }
+
+    public function __unserialize(array $data)
+    {
+        foreach ($data as $key => $value) {
+            $this->{$key} = $value;
+        }
+
+        $this->session = app(Session::class);
+    }
+}