Replacer is not working when response is not cached

[daffamumtaz2361]

Now I know this has been reported before at #262, but I feel like I need to bring this up again.

I think this library should run prepareResponseToCache if the cache doesn't exists and store the response in cache, but then it should run replaceInCachedResponse and send the response. This way the placeholder will never be sent.

Also the replacer documentation is outdated, it should've been prepareResponseToCache instead of transformInitialResponse.
Or is that method actually valid?

[KeitelDOG]

Hello I'm using the package and it's working. But I can't even see the Replacer codes in my version: I'm using "spatie/laravel-responsecache": "^5.0", , and it seems to be removed. Am I doing something wrong? Or is there any alternative?

[KeitelDOG]

Seems like I'm gonna have to fetch a new CSFR Token at each page load and set it to header and all inputs that uses it <input name="_token" ... />

[bendadaniel]

Any new solution please? I have same problem

[KeitelDOG]

I ended up using my own code to cache pages with Spatie package code in a very efficient way. My pages goes from 0.5s to 0.024s, from 0.13 to 0.021s, or even less like 0.01 on low server loads.

• I catch code at After Middleware to check if there is a response page in cache and grab it to return it instead
• I create a ResponseCache class in app\Libraries directory with methods to achieve it
• I use Spatie/ResponseCache/ResponseSerializer class to serialize response before caching it
• If no response in cache, then I run the normal $response = $next($request);, and after that, I cache this page if necessary under my conditions.

I control it all on After Middleware, so that it's easy to change it, or cancel it any time.

When caching a page, I inject Delimiters into HTML text, and when getting a cached page, I just replace the delimiters. Replace in HTML response exponentially faster then having to add dynamic data while creating HMTL response:

$html = $response->getContent();
$html = str_replace('[[csrf-token-here]]', csrf_token(), $html);
$html = str_replace('[[elapsed-here]]', Megalo::getElapsed(), $html);
$response->setContent($html);

For now I keep it cached for Guests, that requires only CSRF tokens. But for Users, you can just load it async from browser javascript, or just put Delimiters in User Info tags, and then replace them with just 1 DB request that would have no significant speed from the cache point of view.

This is my ResponseCache class as an example:

<?php

namespace App\Libraries;

use Illuminate\Http\Request;
use Illuminate\Support\Facades\Cache;
use Illuminate\Support\Facades\Session;
use Illuminate\Support\Facades\Auth;
use Illuminate\Support\Facades\Input;
use Illuminate\Support\Str;

use Spatie\ResponseCache\ResponseSerializer;

use Exception;
use DOMDocument;
use DOMXPath;

class ResponseCache {

    // Let's serve cache for showEntity and listEntity from
    // Lrc, Band, Musician, Album, Song, Video, etc.
    protected $allowed = [
        'home' => 60 * 60 * 24 * 1,
        'lrc' => 60 * 60 * 24 * 7,
        'band' => 60 * 60 * 24 * 7,
        'musician' => 60 * 60 * 24 * 7,
        'manager' => 60 * 60 * 24 * 7,
        'photographer' => 60 * 60 * 24 * 7,
        'album' => 60 * 60 * 24 * 3,
        'song' => 60 * 60 * 24 * 1,
        'video' => 60 * 60 * 24 * 3,
        'playlist' => 60 * 60 * 24 * 1,
        'genre' => 60 * 60 * 24 * 7,
        'instrument' => 60 * 60 * 24 * 7,
        'occasion' => 60 * 60 * 24 * 7,
        'occasion-title' => 60 * 60 * 24 * 7,
    ];

	public function grab(Request $request)
	{
        // if cached response should not be grabbed, then abort
        if (!$this->shouldGrab()) {
            return;
        }

        $key = $this->keygen($request->url(), Megalo::$mobileView);

        if(Cache::store('file')->has($key)) {
            $serializer = new ResponseSerializer();
            $szdResponse = Cache::store('file')->get($key);
            return $serializer->unserialize($szdResponse);
        }
	}

	public function set(Request $request, $response)
	{
        // if response should not be cached, then abort
        if (!$this->shouldCache($request, $response)) {
            return;
        }

        // calculate minutes for cache
        $entity = Megalo::$resourceName;
		$action = Megalo::$actionName;
        // 1 hour default
        $minutes = 60 * 60 * 1;
        if (key_exists($entity, $this->allowed)) {
            $minutes = $this->allowed[$entity];
        }
        // if page is lrcMaker then set 1 day
        if ($entity === 'lrc' && $action === 'maker') {
            $minutes = 60 * 60 * 24 * 1;
        }

        $key = $this->keygen($request->url(), Megalo::$mobileView);

        try {
            if(!Cache::store('file')->has($key)) {
                // add template tag for csrf token
                $html = $this->tagCSRFToken($response);
                $response->setContent($html);

                // Serialize the response
                $serializer = new ResponseSerializer();
                $szdResponse = $serializer->serialize($response);
                Cache::store('file')->put($key, $szdResponse, $minutes);

                // put back the original token
                $html = str_replace('[[csrf-token-here]]', csrf_token(), $html);
                $response->setContent($html);
            }
        } catch (Exception $e) {
            // should delete cache
            Cache::store('file')->forget($key);
        }
	}

    public function forget(String $url)
	{
        $computerKey = $this->keygen($url, false);
        $mobileKey = $this->keygen($url, true);
        Cache::store('file')->forget($computerKey);
        Cache::store('file')->forget($mobileKey);
	}

    protected function shouldGrab()
    {
        if (Session::has('active_approle_id')) {
            return false;
        }

        if (Input::has('nocache')) {
            return false;
        }

        return true;
    }

    protected function shouldCache(Request $request, $response)
    {
        if ($request->ajax()) {
            return false;
        }

        if (!$request->isMethod('get')) {
            return false;
        }

        if (Auth::check()) {
			return false;
		}

		// now we have Guest only
		$entity = Megalo::$resourceName;
		$action = Megalo::$actionName;

        // skip if not from allowed Resources
		if (!key_exists($entity, $this->allowed)) {
			return false;
		}

        // allow home
        if ($entity !== 'home') {
            // allow lrc maker
            if ($entity !== 'lrc' && $action !== 'maker') {
                // skip if not showEntity and listEntity (normal Pages) except for Home
                if ($action !== 'listEntity' && $action !== 'showEntity') {
                    return;
                }
            } else {
                // do not cache lrc in edit mode like lrc/maker?lrc=12345
                if (Input::has('lrc')) {
                    return;
                }
            }
        }

        return $response->isSuccessful();
    }

    protected function keygen($url, $mobileView = false)
	{
        $suffix = $mobileView ? 'mobile' : 'computer';

        $key = $suffix . '_' . Str::slug($url);
        if (Input::has('sort')) {
            $key .= 'sort=' . Input::get('sort');
        }
        if (Input::has('key')) {
            $key .= 'key=' . Input::get('key');
        }
		return $key;
	}

    protected function tagCSRFToken ($response)
	{
		$doc = new DOMDocument();
		@$doc->loadHTML($response->getContent());
		$xpath = new DOMXpath($doc);
		$inputs = $xpath->query('//input[@name="_token"]');
		$metas = $xpath->query('//meta[@name="csrf_token"]');

        foreach ($metas as $meta) {
            $meta->setAttribute('content', '[[csrf-token-here]]');
        }

        foreach ($inputs as $input) {
            $input->setAttribute('value', '[[csrf-token-here]]');
        }

		return $xpath->document->saveHTML();
	}
}