API Caching

config/api.php

@@ -39,4 +39,21 @@
 
     'pagination_size' => 50,
 
+    /*
+    |--------------------------------------------------------------------------
+    | Caching
+    |--------------------------------------------------------------------------
+    |
+    | By default, Statamic will cache each endpoint until the specified
+    | expiry, or until content is changed. See the documentation for
+    | more details on how to customize your cache implementation.
+    |
+    | https://statamic.dev/content-api#caching
+    |
+    */
+
+    'cache' => [
+        'expiry' => 60,
+    ],
+
 ];

resources/js/components/publish/SaveButtonOptions.vue

@@ -78,12 +78,10 @@ export default {
         },
     },
 
-    watch: {
-        currentOption: 'setPreference',
-    },
-
     mounted() {
         this.setInitialValue();
+
+        this.$watch('currentOption', value => this.setPreference(value));
     },
 
     methods: {

routes/routes.php

@@ -1,6 +1,7 @@
 <?php
 
 use Illuminate\Support\Facades\Route;
+use Statamic\API\Middleware\Cache;
 use Statamic\Http\Middleware\API\SwapExceptionHandler as SwapAPIExceptionHandler;
 use Statamic\Http\Middleware\CP\SwapExceptionHandler as SwapCpExceptionHandler;
 use Statamic\Http\Middleware\RequireStatamicPro;
@@ -9,6 +10,7 @@
     Route::middleware([
         SwapApiExceptionHandler::class,
         RequireStatamicPro::class,
+        Cache::class,
     ])->group(function () {
         Route::middleware(config('statamic.api.middleware'))
             ->name('statamic.api.')

src/API/AbstractCacher.php

@@ -0,0 +1,60 @@
+<?php
+
+namespace Statamic\API;
+
+use Illuminate\Support\Carbon;
+
+abstract class AbstractCacher implements Cacher
+{
+    /**
+     * @var \Illuminate\Support\Collection
+     */
+    private $config;
+
+    /**
+     * Create cacher instance.
+     *
+     * @param array $config
+     */
+    public function __construct($config)
+    {
+        $this->config = collect($config);
+    }
+
+    /**
+     * Get a config value.
+     *
+     * @param mixed $key
+     * @param mixed $default
+     * @return mixed
+     */
+    public function config($key = null, $default = null)
+    {
+        if (is_null($key)) {
+            return $this->config;
+        }
+
+        return $this->config->get($key, $default);
+    }
+
+    /**
+     * Prefix a cache key.
+     *
+     * @param string $key
+     * @return string
+     */
+    protected function normalizeKey($key)
+    {
+        return "api-cache:$key";
+    }
+
+    /**
+     * Get cache expiry.
+     *
+     * @return \Carbon\Carbon
+     */
+    public function cacheExpiry()
+    {
+        return Carbon::now()->addMinutes($this->config('expiry'));
+    }
+}

src/API/ApiCacheManager.php

@@ -0,0 +1,68 @@
+<?php
+
+namespace Statamic\API;
+
+use InvalidArgumentException;
+use Statamic\API\Cachers\DefaultCacher;
+use Statamic\API\Cachers\NullCacher;
+use Statamic\Support\Manager;
+
+class ApiCacheManager extends Manager
+{
+    public function getDefaultDriver()
+    {
+        $config = $this->app['config']['statamic.api.cache'];
+        $class = $this->app['config']['statamic.api.cache.class'];
+
+        switch (true) {
+            case $config === false:
+            case $class === false:
+                return false;
+            case is_string($class):
+                return $class;
+            default:
+                return DefaultCacher::class;
+        }
+    }
+
+    public function createNullDriver()
+    {
+        return new NullCacher;
+    }
+
+    public function createClassDriver(string $driverClass, array $config)
+    {
+        return new $driverClass($config);
+    }
+
+    protected function getConfig($name)
+    {
+        if (! $config = $this->app['config']['statamic.api.cache']) {
+            return null;
+        }
+
+        return collect($config)
+            ->except('class')
+            ->all();
+    }
+
+    protected function resolve($driver)
+    {
+        if (! $driver) {
+            return $this->createNullDriver();
+        }
+
+        $config = $this->getConfig($driver);
+
+        if (is_null($config)) {
+            throw new InvalidArgumentException($this->invalidImplementationMessage($driver));
+        }
+
+        return $this->createClassDriver($driver, $config);
+    }
+
+    protected function invalidImplementationMessage($name)
+    {
+        return "Api cache config for [{$name}] is not properly defined.";
+    }
+}

src/API/Cacher.php

@@ -0,0 +1,35 @@
+<?php
+
+namespace Statamic\API;
+
+use Illuminate\Http\JsonResponse;
+use Illuminate\Http\Request;
+use Statamic\Events\Event;
+
+interface Cacher
+{
+    /**
+     * Get a response from the cache.
+     *
+     * @param Request $request
+     * @return JsonResponse|null
+     */
+    public function get(Request $request);
+
+    /**
+     * Put a response into the cache.
+     *
+     * @param Request $request
+     * @param JsonResponse $response
+     * @return void
+     */
+    public function put(Request $request, JsonResponse $response);
+
+    /**
+     * Handle event based API cache invalidation.
+     *
+     * @param Event $event
+     * @return void
+     */
+    public function handleInvalidationEvent(Event $event);
+}

src/API/Cachers/DefaultCacher.php

@@ -0,0 +1,103 @@
+<?php
+
+namespace Statamic\API\Cachers;
+
+use Illuminate\Http\JsonResponse;
+use Illuminate\Http\Request;
+use Illuminate\Support\Facades\Cache;
+use Statamic\API\AbstractCacher;
+use Statamic\Events\Event;
+
+class DefaultCacher extends AbstractCacher
+{
+    /**
+     * {@inheritdoc}
+     */
+    public function get(Request $request)
+    {
+        return Cache::get($this->getCacheKey($request));
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function put(Request $request, JsonResponse $response)
+    {
+        $key = $this->trackEndpoint($request);
+
+        Cache::put($key, $response, $this->cacheExpiry());
+    }
+
+    /**
+     * Handle event based API cache invalidation.
+     *
+     * @param Event $event
+     * @return void
+     */
+    public function handleInvalidationEvent(Event $event)
+    {
+        $this->getTrackedResponses()->each(function ($key) {
+            Cache::forget($key);
+        });
+
+        Cache::forget($this->getTrackingKey());
+    }
+
+    /**
+     * Track endpoint and return new cache key.
+     *
+     * @param Request $request
+     * @return string
+     */
+    protected function trackEndpoint($request)
+    {
+        $newKey = $this->getCacheKey($request);
+
+        $keys = $this
+            ->getTrackedResponses()
+            ->push($newKey)
+            ->unique()
+            ->values()
+            ->all();
+
+        Cache::put($this->getTrackingKey(), $keys);
+
+        return $newKey;
+    }
+
+    /**
+     * Get tracked responses.
+     *
+     * @return \Illuminate\Support\Collection
+     */
+    protected function getTrackedResponses()
+    {
+        return collect(Cache::get($this->getTrackingKey(), []));
+    }
+
+    /**
+     * Get tracking cache key for storing invalidatable endpoints.
+     *
+     * @return string
+     */
+    protected function getTrackingKey()
+    {
+        return $this->normalizeKey('tracked-responses');
+    }
+
+    /**
+     * Get cache key for endpoint.
+     *
+     * @param Request $request
+     * @return string
+     */
+    protected function getCacheKey(Request $request)
+    {
+        $domain = $request->root();
+        $fullUrl = $request->fullUrl();
+
+        $key = str_replace($domain, '', $fullUrl);
+
+        return $this->normalizeKey($key);
+    }
+}

src/API/Cachers/NullCacher.php

@@ -0,0 +1,26 @@
+<?php
+
+namespace Statamic\API\Cachers;
+
+use Illuminate\Http\JsonResponse;
+use Illuminate\Http\Request;
+use Statamic\API\Cacher;
+use Statamic\Events\Event;
+
+class NullCacher implements Cacher
+{
+    public function get(Request $request)
+    {
+        //
+    }
+
+    public function put(Request $request, JsonResponse $response)
+    {
+        //
+    }
+
+    public function handleInvalidationEvent(Event $event)
+    {
+        //
+    }
+}

src/API/Middleware/Cache.php

@@ -0,0 +1,48 @@
+<?php
+
+namespace Statamic\API\Middleware;
+
+use Closure;
+use Statamic\API\Cacher;
+use Statamic\Exceptions\NotFoundHttpException;
+
+class Cache
+{
+    /**
+     * Handle an incoming request.
+     *
+     * @param  \Illuminate\Http\Request  $request
+     * @param  \Closure  $next
+     * @return mixed
+     */
+    public function handle($request, Closure $next)
+    {
+        $cacher = app(Cacher::class);
+
+        if ($response = $cacher->get($request)) {
+            return $response;
+        }
+
+        $response = $next($request);
+
+        if ($this->shouldBeCached($response)) {
+            $cacher->put($request, $this->cleanResponse($response));
+        }
+
+        return $response;
+    }
+
+    private function shouldBeCached($response)
+    {
+        return $response->isOk() || $response->isNotFound();
+    }
+
+    private function cleanResponse($response)
+    {
+        if ($response->exception instanceof NotFoundHttpException) {
+            $response->exception = null;
+        }
+
+        return $response;
+    }
+}