Caching Real Queries

Caching is a trade: an older answer, faster. The work is deciding which answers may be old, and for how long.

What is worth caching

Three shapes cover most of it. A computed fragment, such as a rendered list of featured products. A number that costs a scan, such as a count or a sum. A lookup that barely changes, such as plan limits. All three are read far more often than they change.

Expiry or invalidation

A TTL is a promise about how stale a value may get. Cache::remember($key, 300, ...) says five minutes of wrong is acceptable. Explicit invalidation promises the value is never wrong: the code that writes the data calls Cache::forget() on the key, or Cache::tags([...])->flush() on the group. Use a TTL for figures nobody audits, and invalidation for anything a user will compare against the source.

The stale answer nobody may see

Never cache per-user data under a shared key. A key like orders.recent, filled by whoever hit the page first, serves one customer's orders to everyone. Put the identity in the key, or do not cache. The same caution applies to anything the user acts on: a price, a balance, a permission.

When a popular key expires, every request that misses runs the closure at once. Cache::flexible($key, [$fresh, $stale], $callback) handles that: inside the first window the cached value is returned, between the two it is still returned and a deferred function refreshes it after the response is sent, and past the second window one request recomputes and waits.

<?php
// app/Support/ProductStats.php

declare(strict_types=1);

namespace App\Support;

use App\Models\Product;
use Illuminate\Support\Facades\Cache;

class ProductStats
{
    /**
     * One place that names the key, so the writer and the reader agree.
     */
    public const IN_STOCK_KEY = 'products.in-stock-count';

    public function inStockCount(): int
    {
        return Cache::remember(
            self::IN_STOCK_KEY,
            300,
            fn (): int => Product::where('stock', '>', 0)->count(),
        );
    }

    public function forgetInStockCount(): void
    {
        Cache::forget(self::IN_STOCK_KEY);
    }
}

<?php
// app/Observers/ProductObserver.php

declare(strict_types=1);

namespace App\Observers;

use App\Models\Product;
use App\Support\ProductStats;
use Illuminate\Support\Facades\Cache;

class ProductObserver
{
    public function saved(Product $product): void
    {
        Cache::forget(ProductStats::IN_STOCK_KEY);
    }

    public function deleted(Product $product): void
    {
        Cache::forget(ProductStats::IN_STOCK_KEY);
    }
}

use App\Models\Order;
use Illuminate\Support\Facades\Cache;

$stats = Cache::flexible('dashboard.stats', [60, 600], function (): array {
    return [
        'orders' => Order::count(),
        'revenue' => (float) Order::where('status', 'paid')->sum('total'),
    ];
});

// app/Http/Controllers/OrderController.php

public function index(Request $request): View
{
    $user = $request->user();

    $orders = Cache::tags(['orders', 'user:'.$user->id])->remember(
        "orders.recent.{$user->id}",
        120,
        fn () => $user->orders()->latest()->take(5)->get(),
    );

    return view('orders.index', ['orders' => $orders]);
}