[4.x] Cache prefix mode for separating tenant caches

assets/config.php

@@ -102,6 +102,7 @@
         Stancl\Tenancy\Bootstrappers\FilesystemTenancyBootstrapper::class,
         Stancl\Tenancy\Bootstrappers\QueueTenancyBootstrapper::class,
         Stancl\Tenancy\Bootstrappers\BatchTenancyBootstrapper::class,
+        // Stancl\Tenancy\Bootstrappers\PrefixCacheTenancyBootstrapper::class,
         // Stancl\Tenancy\Bootstrappers\RedisTenancyBootstrapper::class, // Note: phpredis is needed
     ],
 
@@ -187,6 +188,7 @@
      */
     'cache' => [
         'tag_base' => 'tenant', // This tag_base, followed by the tenant_id, will form a tag that will be applied on each cache call.
+        'prefix_base' => 'tenant_', // This prefix_base, followed by the tenant_id, will form a cache prefix that will be used for every cache key.
     ],
 
     /**

src/Bootstrappers/PrefixCacheTenancyBootstrapper.php

@@ -0,0 +1,57 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Stancl\Tenancy\Bootstrappers;
+
+use Illuminate\Cache\Repository;
+use Illuminate\Contracts\Foundation\Application;
+use Illuminate\Support\Facades\Cache;
+use Stancl\Tenancy\Contracts\TenancyBootstrapper;
+use Stancl\Tenancy\Contracts\Tenant;
+
+class PrefixCacheTenancyBootstrapper implements TenancyBootstrapper
+{
+    protected null|string $originalPrefix = null;
+    protected string $storeName;
+
+    public function __construct(
+        protected Application $app
+    ) {
+    }
+
+    public function bootstrap(Tenant $tenant): void
+    {
+        $this->originalPrefix = $this->app['config']['cache.prefix'];
+        $this->storeName = $this->app['config']['cache.default'];
+
+        $this->setCachePrefix($this->app['config']['tenancy.cache.prefix_base'] . $tenant->getTenantKey());
+    }
+
+    public function revert(): void
+    {
+        $this->setCachePrefix($this->originalPrefix);
+        $this->originalPrefix = null;
+    }
+
+    protected function setCachePrefix(null|string $prefix): void
+    {
+        $this->app['config']['cache.prefix'] = $prefix;
+
+        $this->app['cache']->forgetDriver($this->storeName);
+
+        // The CacheManager will have the $app['config'] array cached with old prefixes on the 'cache' instance
+        // This call will forget the 'cache' instance
+        $this->app->forgetInstance('cache');
+
+        // The Cache Repository is using an old version of the CacheManager so we need to forget it
+        $this->app->forgetInstance('cache.store');
+
+        // Forget the cache repository in the container to cover some edge-cases
+        $this->app->forgetInstance(Repository::class);
+
+        // It is needed when a call to the facade has been made before bootstrapping tenancy
+        // The facade has its own cache, separate from the container
+        Cache::clearResolvedInstances();
+    }
+}

tests/BootstrapperTest.php

@@ -6,6 +6,7 @@
 use Illuminate\Support\Facades\DB;
 use Stancl\JobPipeline\JobPipeline;
 use Illuminate\Support\Facades\File;
+use Stancl\Tenancy\Bootstrappers\PrefixCacheTenancyBootstrapper;
 use Stancl\Tenancy\Tests\Etc\Tenant;
 use Illuminate\Support\Facades\Cache;
 use Illuminate\Support\Facades\Event;
@@ -73,11 +74,9 @@
     expect(DB::table('users')->first()->name)->toBe('Foo');
 });
 
-test('cache data is separated', function () {
+test('cache data is separated', function (string $bootstrapper) {
     config([
-        'tenancy.bootstrappers' => [
-            CacheTenancyBootstrapper::class,
-        ],
+        'tenancy.bootstrappers' => [$bootstrapper],
         'cache.default' => 'redis',
     ]);
 
@@ -112,7 +111,10 @@
 
     // Asset central is still the same
     expect(Cache::get('foo'))->toBe('central');
-});
+})->with([
+    'CacheTenancyBootstrapper' => CacheTenancyBootstrapper::class,
+    'PrefixCacheTenancyBootstrapper' => PrefixCacheTenancyBootstrapper::class,
+]);
 
 test('redis data is separated', function () {
     config(['tenancy.bootstrappers' => [

tests/PrefixCacheBootstrapperTest.php

@@ -0,0 +1,119 @@
+<?php
+
+declare(strict_types=1);
+
+use Illuminate\Support\Facades\Event;
+use Stancl\Tenancy\Bootstrappers\PrefixCacheTenancyBootstrapper;
+use Stancl\Tenancy\Events\TenancyEnded;
+use Stancl\Tenancy\Events\TenancyInitialized;
+use Stancl\Tenancy\Listeners\BootstrapTenancy;
+use Stancl\Tenancy\Listeners\RevertToCentralContext;
+
+beforeEach(function () {
+    config([
+        'tenancy.bootstrappers' => [PrefixCacheTenancyBootstrapper::class],
+        'cache.default' => 'redis',
+    ]);
+
+    Event::listen(TenancyInitialized::class, BootstrapTenancy::class);
+    Event::listen(TenancyEnded::class, RevertToCentralContext::class);
+});
+
+test('cache prefix is separate for each tenant', function () {
+    $originalPrefix = config('cache.prefix') . ':';
+    cache()->set('key', 'original-value');
+
+    expect($originalPrefix)
+        ->toBe(app('cache')->getPrefix())
+        ->toBe(app('cache.store')->getPrefix());
+
+    $tenant1 = Tenant::create();
+    $tenant2 = Tenant::create();
+
+    $tenantOnePrefix = 'tenant_' . $tenant1->id . ':';
+
+    tenancy()->initialize($tenant1);
+    cache()->set('key', 'tenantone-value');
+
+    expect($tenantOnePrefix)
+        ->toBe(app('cache')->getPrefix())
+        ->toBe(app('cache.store')->getPrefix());
+
+    $tenantTwoPrefix = 'tenant_' . $tenant2->id . ':';
+
+    tenancy()->initialize($tenant2);
+    cache()->set('key', 'tenanttwo-value');
+
+    expect($tenantTwoPrefix)
+        ->toBe(app('cache')->getPrefix())
+        ->toBe(app('cache.store')->getPrefix());
+
+    // Assert tenants' data is accessible using the prefix from the central context
+    tenancy()->end();
+    config(['cache.prefix' => null]); // stop prefixing cache keys in central
+
+    expect(cache($tenantOnePrefix . 'key'))->toBe('tenantone-value');
+    expect(cache($tenantTwoPrefix . 'key'))->toBe('tenanttwo-value');
+});
+
+test('cache is persisted when reidentification is used', function () {
+    $tenant1 = Tenant::create();
+    $tenant2 = Tenant::create();
+    tenancy()->initialize($tenant1);
+
+    cache(['foo' => 'bar'], 10);
+    expect(cache('foo'))->toBe('bar');
+
+    tenancy()->initialize($tenant2);
+    tenancy()->end();
+
+    tenancy()->initialize($tenant1);
+    expect(cache('foo'))->toBe('bar');
+});
+
+test('prefix separate cache well enough', function () {
+    $tenant1 = Tenant::create();
+    tenancy()->initialize($tenant1);
+
+    cache()->put('foo', 'bar', 1);
+    expect(cache()->get('foo'))->toBe('bar');
+
+    $tenant2 = Tenant::create();
+    tenancy()->initialize($tenant2);
+
+    pest()->assertNotSame('bar', cache()->get('foo'));
+
+    cache()->put('foo', 'xyz', 1);
+    expect(cache()->get('foo'))->toBe('xyz');
+});
+
+test('central cache is persisted', function () {
+    cache()->put('key', 'central');
+
+    $tenant1 = Tenant::create();
+    tenancy()->initialize($tenant1);
+
+    cache()->put('key', 'tenant');
+
+    expect(cache()->get('key'))->toBe('tenant');
+
+    tenancy()->end();
+    cache()->put('key2', 'central-two');
+
+    expect(cache()->get('key'))->toBe('central');
+    expect(cache()->get('key2'))->toBe('central-two');
+});
+
+test('cache base prefix is customizable', function () {
+    config([
+        'tenancy.cache.prefix_base' => 'custom_'
+    ]);
+
+    $tenant1 = Tenant::create();
+    tenancy()->initialize($tenant1);
+
+    expect('custom_' . $tenant1->id . ':')
+        ->toBe(app('cache')->getPrefix())
+        ->toBe(app('cache.store')->getPrefix());
+});
+

tests/TestCase.php

@@ -8,7 +8,7 @@
 use Illuminate\Foundation\Application;
 use Illuminate\Support\Facades\Redis;
 use PDO;
-use Stancl\Tenancy\Bootstrappers\BatchTenancyBootstrapper;
+use Stancl\Tenancy\Bootstrappers\PrefixCacheTenancyBootstrapper;
 use Stancl\Tenancy\Bootstrappers\RedisTenancyBootstrapper;
 use Stancl\Tenancy\Facades\GlobalCache;
 use Stancl\Tenancy\Facades\Tenancy;
@@ -113,6 +113,7 @@ protected function getEnvironmentSetUp($app)
         ]);
 
         $app->singleton(RedisTenancyBootstrapper::class); // todo (Samuel) use proper approach eg config for singleton registration
+        $app->singleton(PrefixCacheTenancyBootstrapper::class); // todo (Samuel) use proper approach eg config for singleton registration
     }
 
     protected function getPackageProviders($app)