Laravel Cacheable Model Laravel Package

Technical Evaluation

Architecture Fit

• Query Caching Paradigm: Continues to align well with Laravel’s Eloquent ORM, maintaining a declarative approach to caching model queries. The fix for whereNull edge cases (PR #56) improves robustness for complex queries, addressing a potential gap in handling NULL conditions.
• Cache Granularity: Retains the strength of query-based caching, avoiding stale data issues. The package’s design remains ideal for read-heavy, infrequently updated data.
• Laravel Ecosystem: Now officially supports Laravel 11+ (previously 10+) and PHP 8.5, aligning with modern Laravel stacks. Leverages Laravel’s built-in cache drivers without vendor lock-in.

Integration Feasibility

• Low Friction: The Cacheable trait remains the primary integration point, with minimal configuration required. The whereNull fix reduces boilerplate for queries involving NULL checks.
• Automatic Invalidation: Listeners for created, updated, and deleted events are unchanged, ensuring cache consistency. No breaking changes to invalidation logic.
• Query Uniqueness: The uniqueQueries and cacheKey() methods remain functional, with the whereNull fix improving key generation for edge cases.

Technical Risk

• PHP 8.5 Compatibility: While the package now supports PHP 8.5, ensure your team’s CI/CD pipelines and local environments are updated to avoid runtime errors (e.g., strict typing, named arguments).
• Laravel 11+ Dependencies: Verify compatibility with Laravel 11’s internal changes (e.g., service provider booting, event system). Test with Laravel 11’s default cache drivers.
• Cache Key Collisions: The whereNull fix mitigates one edge case, but complex queries (e.g., nested orWhere, whereDoesntHave) may still require explicit cacheKey() overrides.
• Performance Overhead: Cache invalidation listeners add minor overhead to write operations. Benchmark in high-write scenarios (e.g., >10K writes/minute) to validate scalability.

Key Questions

1. Laravel 11+ Migration:

   • Are there breaking changes in Laravel 11 (e.g., service providers, events) that could affect cache invalidation listeners?
   • How will the package handle Laravel 11’s updated query builder or Eloquent methods?

2. PHP 8.5 Features:

   • Does the package leverage PHP 8.5 features (e.g., new attributes, enums) that could impact backward compatibility?
   • Are there runtime warnings or deprecations in PHP 8.5 that could affect cache key generation?

3. Edge Case Coverage:

   • Are there other query edge cases (e.g., whereRaw, orWhereNull) that could benefit from similar fixes?
   • How will the package handle NULL in composite keys (e.g., cacheKey() returning null)?

4. Cache Driver Updates:

   • Does the package support Laravel 11’s updated cache driver interfaces (e.g., Cache::store() changes)?
   • Are there performance improvements in Redis/Memcached drivers (e.g., Laravel 11’s Redis clustering) that could be leveraged?

5. Deprecation Warnings:

   • Are there deprecated Laravel 10 features in the package that could trigger warnings in Laravel 11?
   • How will the package handle deprecated Eloquent methods (e.g., increment() vs. update())?

Integration Approach

Stack Fit

• Laravel Version: Now officially supports Laravel 11+ (previously 10+). Ensure your project’s composer.json constraints allow Laravel 11:

  "require": {
      "laravel/framework": "^11.0",
      "php": "^8.5"
  }
  

• Cache Drivers: Continues to support Redis, Memcached, database, and file drivers. Laravel 11’s Redis clustering improvements (e.g., redis:cluster) should be tested for cache consistency.
• Database Compatibility: Works with all Eloquent-supported databases. Test with Laravel 11’s query builder changes (e.g., whereNull optimizations).

Migration Path

1. Prerequisite Updates:
   • Upgrade Laravel to 11.x and PHP to 8.5 in staging.
   • Update composer.json dependencies and run composer update.
2. Pilot Phase:
   • Test the whereNull fix with models using whereNull queries (e.g., Model::whereNull('deleted_at')->get()).
   • Validate cache key generation for these queries.
3. Incremental Rollout:
   • Enable caching for read-heavy endpoints first, prioritizing queries with NULL checks.
   • Gradually add cacheKey() overrides for complex queries.
4. Configuration:
   • Update config/cacheable.php to reflect Laravel 11’s cache driver defaults (if applicable).
   • Example for Laravel 11’s Redis clustering:

     'driver' => env('CACHE_DRIVER', 'redis-cluster'),
     'redis' => [
         'cluster' => true,
         'options' => [
             'cluster' => 'redis',
             'database' => 0,
         ],
     ],
     

Compatibility

• Existing Code: The whereNull fix is backward-compatible. No changes required for existing models using the trait.
• Third-Party Packages: Audit for conflicts with other cache-related packages (e.g., spatie/laravel-cache). Laravel 11’s updated service container may affect package initialization order.
• Testing:
  • Use Laravel’s Cache::fake() in PHPUnit to mock cache behavior, including whereNull queries.
  • Test with Laravel 11’s assertDatabaseMissing()/assertDatabaseHas() for cache invalidation validation.

Sequencing

1. Setup:
   • Install the updated package: composer require elipzis/laravel-cacheable-model:^0.6.0.
   • Publish config: php artisan vendor:publish --tag="cacheable-config".
2. Configuration:
   • Update .env for Laravel 11’s cache driver (e.g., CACHE_DRIVER=redis-cluster).
   • Configure PHP 8.5’s error reporting (e.g., E_DEPRECATED for Laravel 10 deprecations).
3. Model Integration:
   • Add the Cacheable trait to models as before. Test with whereNull queries first.
   • Example:

     use ElipZis\Cacheable\Models\Traits\Cacheable;
     
     class User extends Model {
         use Cacheable;
     
         protected $cacheTTL = 3600;
     }
     

4. Validation:
   • Verify cache keys for whereNull queries:

     $key = Cacheable::getCacheKey(User::whereNull('deleted_at')->get());
     

   • Check invalidation with User::whereNull('deleted_at')->update(['active' => false]).
5. Optimization:
   • Fine-tune uniqueQueries and cacheKey() for queries involving NULL or complex conditions.
   • Monitor cache performance with Laravel 11’s improved metrics (e.g., Cache::stats()).

Operational Impact

Maintenance

• Configuration Drift: Centralized config remains in config/cacheable.php. Use Laravel 11’s environment-based configuration (e.g., config/laravel11.php) for environment-specific settings.
• Dependency Updates: Monitor for Laravel 11 minor releases and PHP 8.5 bug fixes. Test upgrades in staging with:

  composer require laravel/framework:^11.10 --dev
  

• Cache Schema: Document updated cache key patterns for whereNull queries (e.g., model:query_hash:with_null_checks). Example:

  users:whereNull_deleted_at:1634567890:3600
  

Support

• Debugging:
  • Enable debug mode for cache keys:

    \ElipZis\Cacheable\Support\Facades\Cacheable::debug(true);
    

  • Use Laravel 11’s dd() helper or tap() for inspecting cache keys in whereNull queries.
• Common Issues:
  • PHP 8.5 Warnings: Suppress deprecation warnings for Laravel 10 features with error_reporting(E_ALL & ~E_DEPRECATED) in .env.
  • Cache Bloat: Implement size-based purging with Laravel 11’s Cache::rememberForever() alternatives.
• Support Tools: Integrate with Laravel 11’s Horizon or Sentry for cache-related errors. Example Sentry event:

  try {
      $users = User::whereNull('deleted_at')->cached();
  } catch (\Exception $e) {
      Sentry::captureException($e, [
          'cache_key' => Cacheable::getCacheKey($users),
      ]);
  }
  

Scaling

• Horizontal Scaling:
  • Le