Create Cache Aside

Cache-Aside Generator

Creates Cache-Aside infrastructure with stampede protection and tag-based invalidation.

When to Use

Component Characteristics

CacheAsideInterface

• get(string $key, callable $loader, int $ttl): mixed — load from cache or compute
• invalidate(string $key): void — remove specific cache entry
• invalidateByTag(string $tag): void — remove all entries tagged with given tag

CacheKeyGenerator

• Builds deterministic cache keys from prefix and parameters
• Hashes long keys to prevent exceeding storage limits
• Supports tag-based key grouping

CacheAsideExecutor

• PSR-16 SimpleCache integration
• Configurable TTL per cache operation
• Stampede protection via distributed locking
• Prevents thundering herd on cache miss

CacheInvalidator

• Tag-based invalidation (invalidate all entries for a tag)
• Pattern-based clearing (wildcard key matching)
• Batch invalidation support

Generation Process

Step 1: Generate Domain Components

Path: src/Domain/Shared/Cache/

1. CacheAsideInterface.php — Cache-aside contract
2. CacheKeyGeneratorInterface.php — Key generation contract

Step 2: Generate Infrastructure Components

Path: src/Infrastructure/Cache/

1. CacheKeyGenerator.php — Key builder with hashing
2. CacheAsideExecutor.php — PSR-16 cache executor with locking
3. CacheInvalidator.php — Tag-based and pattern-based invalidation
4. CacheLockInterface.php — Distributed lock contract
5. RedisCacheLock.php — Redis-based lock implementation

Step 3: Generate Tests

1. CacheKeyGeneratorTest.php — Key generation and hashing tests
2. CacheAsideExecutorTest.php — Cache hit/miss, stampede protection tests
3. CacheInvalidatorTest.php — Tag and pattern invalidation tests

File Placement

Naming Conventions

Quick Template Reference

CacheAsideInterface

interface CacheAsideInterface
{
    /**
     * @template T
     * @param callable(): T $loader
     * @return T
     */
    public function get(string $key, callable $loader, int $ttl = 3600): mixed;
    public function invalidate(string $key): void;
    public function invalidateByTag(string $tag): void;
}

CacheKeyGenerator

final readonly class CacheKeyGenerator
{
    public function __construct(private string $prefix = 'app');
    public function generate(string $context, string ...$parts): string;
    public function generateHashed(string $context, string ...$parts): string;
}

CacheLockInterface

interface CacheLockInterface
{
    public function acquire(string $key, int $ttl = 10): bool;
    public function release(string $key): void;
}

Usage Example

$executor = new CacheAsideExecutor($cache, $lock, defaultTtl: 3600);

// Cache-aside: returns cached value or computes via loader
$product = $executor->get(
    key: 'product:123',
    loader: fn() => $repository->findById(123),
    ttl: 1800
);

// Invalidate on update
$executor->invalidate('product:123');

// Tag-based invalidation
$invalidator->invalidateByTag('products');

Pattern Comparison

Anti-patterns to Avoid

References

For complete PHP templates and examples, see:

• references/templates.md — CacheAsideInterface, CacheKeyGenerator, CacheAsideExecutor, CacheInvalidator, lock templates
• references/examples.md — Repository integration, event-driven invalidation, and unit tests