Add a rememberLazily method to the cache repository.

[pascalvgemert]

Hi, my name is Pascal 👋 and during this LaraconEU @timacdonald got me thinking about a lazy cache remember function. A function which for example caches a value for an hour and and when it expires it does not immediately refreshes the value, but will do it afterwards and return the expired value just once. As most of the time a certain cache is used when there is lots of demand for the value and it can be cached. So if in this cache it's not stored the actual hour, but lets say an hour and one minute.

So I came up with this idea and I'm really curious about the opinion of you, the community, so here it is:

public function rememberLazily($key, $ttl, Closure $callback)
{
    $lazyValue = $this->get($key);

    // If the item does not exists in the cache we will store a lazy cache object
    // consisting of the time the item should expire, the callback used to get
    // the value and the actual value. We will then return the actual value.
    if ($lazyValue === null) {
        $this->forever($key, new LazyCacheObject(
            value: $value = $callback(),
            resolver: $callback,
            ttl: $ttl,
        ));

        return $value;
    }

    $forceRefresh = false;

    // If the found cache value is not an instance of LazyCacheObject, probably
    // the value was stored using another caching method, in this case we'll
    // turn the value into an expired lazy cache object and just continue.
    if (!$lazyValue instanceof LazyCacheObject) {
        $forceRefresh = true;

        $lazyValue = new LazyCacheObject(
            value: $lazyValue,
            resolver: $callback,
            ttl: $ttl,
        );
    }

    // If the lazy cache object has expired, we'll dispatch a closure to refresh
    // the cache lazily in the background to avoid blocking the process. Then
    // we will use the expired value to return as the result once and fast.
    if ($forceRefresh || $lazyValue->hasExpired()) {
        dispatch(fn () =>
            $this->forever($key, $lazyValue->fresh())
        ); // Would be nice to use ->afterwards();
    }

    return $lazyValue->value;
}

The LazyCacheObject will look like this:

<?php

namespace Illuminate\Cache;

use Closure;
use DateInterval;
use DateTimeInterface;
use Illuminate\Support\Carbon;

class LazyCacheObject
{
    public Carbon $createdAt;

    public function __construct(
        public mixed $value,
        public Closure $resolver,
        public DateInterval|int $ttl = 0,
    ) {
        $this->createdAt = Carbon::now();
    }

    public function hasExpired(): bool
    {
        // See if created at + ttl is in the past
        return $this->ttl instanceof DateTimeInterface
            ? $this->createdAt->add($this->ttl)->isPast()
            : $this->createdAt->addSeconds($this->ttl)->isPast();
    }

    public function fresh(): self
    {
        return new LazyCacheObject(
            value: $this->resolver(),
            resolver: $this->resolver,
            ttl: $this->ttl,
        ))
    }
}

Let me know if you have any suggestions, rephrasing some variables / methods.

I did think of some edge cases, so In case where there could be a longer period of inactivity between the last request and the new one, there could be an option build in which has a kind of threshold. So a cache may expire 10% of the actual TTL, so for a TTL of an hour, the threshold would be like 6 min. Within that timeframe the old value is shown and if it's after the 6 minutes the cache will be refreshed during the request. Another option would be pre-warming the cache, but that will bring quite a lot of challenges to build natively in.

Thank you in advanced ✌🏼

[henzeb]

I was thinking about this idea a little further. I still think this is a lot of overhead to store in the cache, while it is really not needed. Although it removes the risk of a faulty scheduler, we would risk it never getting updated because of a faulty queue. I came up with a better solution, which lowers both risks, by utilizing the queue AND the scheduler. It is probably more what @timacdonald had in mind. and it is not a challenge to build in natively when it comes to preheating/warming up (edit, I saw to late you did queue)

<?php

namespace App\Console;

use Cache;
use DateTimeInterface;
use Illuminate\Bus\Queueable;
use Illuminate\Contracts\Queue\ShouldBeUniqueUntilProcessing;
use Illuminate\Contracts\Queue\ShouldQueue;
use Illuminate\Foundation\Bus\PendingDispatch;
use Illuminate\Queue\InteractsWithQueue;

abstract class Warmable implements ShouldQueue, ShouldBeUniqueUntilProcessing
{
    use Queueable, InteractsWithQueue;

    protected bool $preheated = false;

    public function __construct(
        private ?string                    $key = null,
        private DateTimeInterface|int|null $ttl = null,
        private ?string                    $store = null,
        private bool                       $preheat = true
    )
    {
        if ($this->preheat && !$this->exists()) {
            $this->warmup();
        }
    }

    public function __invoke(): void
    {
        $this->warmup();
    }

    protected function key(): string
    {
        return 'warmable.' . static::class;
    }

    protected function store(): ?string
    {
        return $this->store;
    }

    public function ttl(): DateTimeInterface|int|null
    {
        return $this->ttl;
    }

    abstract protected function warmable(): mixed;

    public static function preheat(
        string                     $key = null,
        DateTimeInterface|int|null $ttl = null,
        string                     $store = null,
    ): PendingDispatch
    {
        return dispatch(new static($key, $ttl, $store, preheat: false));
    }

    public static function withoutPreheating(
        string                     $key = null,
        DateTimeInterface|int|null $ttl = null,
        string                     $store = null,
    ): self
    {
        return new static($key, $ttl, $store, preheat: false);
    }

    public static function witPreheating(
        string                     $key = null,
        DateTimeInterface|int|null $ttl = null,
        string                     $store = null,
    ): self
    {
        return new static($key, $ttl, $store);
    }

    public static function get(
        string                     $key = null,
        DateTimeInterface|int|null $ttl = null,
        string                     $store = null,
        bool                       $preheat = true,
    ): mixed
    {
        $warmable = new static($key, $ttl, $store, $preheat);

        return Cache::store($warmable->getStore())
            ->get(
                $warmable->getKey(),
                fn() => $this->warmable()
            );
    }

    public static function cooldown(
        string $key = null,
        string $store = null
    ): void
    {
        $warmable = new static(
            $key,
            store: $store,
            preheat: false
        );

        Cache::store($warmable->getStore())
            ->delete($warmable->getKey());
    }

    protected function exists(): bool
    {
        return Cache::store($this->getStore())
            ->has($this->getKey());
    }

    private function getStore(): ?string
    {
        return $this->store ?? $this->store();
    }

    private function getKey(): string
    {
        return $this->key ?? $this->key();
    }

    private function getTtl(): DateTimeInterface|int|null
    {
        return $this->ttl ?? $this->ttl();
    }

    protected function warmup(): void
    {
        if ($this->preheated) {
            return;
        }

        Cache::store($this->getStore())
            ->put(
                $this->getKey(),
                $this->warmable(),
                $this->getTtl()
            );

        $this->preheated = true;
    }
}

You are still in control of what needs to be done when it does not exist, as the constructor does preheating by default. You can still define the key you want, the store you want to use and set a TTL. By default TTL is permanent, so if your scheduler fails, users get the old data without ever hitting the slow action.

below an example implementation. It just sleeps 3 seconds and then returns 'hello world'.

class HeavyDatabaseQuery extends Warmable
{
    protected function warmable(): string
    {
        sleep(3);
        return 'hello world';
    }
}

The Warmable is __invokable, you can just throw it in $scheduler->call(HeavyDatabaseQuery::class)->everyFiveMinutes();. You can also throw it into a job with $schedule->job(HeavyDatabaseQuery::class);.

Due to preheating by default, the cache is created in the process of the scheduler instead of the job. use HeavyDatabaseQuery::withoutPreheating() instead. You can use HeavyDatabaseQuery::withPreheating() to ensure it does get preheated in the process of the scheduler, so that you don't have to wait until the scheduler wants to run the process.

Whenever you need the item, you can call HeavyDatabaseQuery::get() and if you want it to cool down, there is a HeavyDatabaseQuery::cooldown() method. And sometimes, when someone change the data, and you don't want to wait 5 minutes until scheduler picks it up, you can call HeavyDatabaseQuery::preheat(). This will queue the Warmable and then your queue picks it up for processing.

If this is something we want to be part of Laravel, I am up for whipping up a PR. If not, I am willing to package this up.

[henzeb]

Couldn't wait, created a package for it. https://github.com/henzeb/warmable-laravel

It also supports grace periods.