[4.x] BroadcastingConfigBootstrapper: fix central instances persisting in tenant context

phpstan.neon

@@ -15,9 +15,9 @@ parameters:
     ignoreErrors:
         - identifier: trait.unused
         - identifier: missingType.iterableValue
-        -
-            message: '#Spatie\\Invade\\Invader#'
-            identifier: method.notFound
+       #-
+       #    message: '#Spatie\\Invade\\Invader#'
+       #    identifier: method.notFound
         -
             message: '#Spatie\\Invade\\Invader#'
             identifier: property.notFound

src/Bootstrappers/BroadcastingConfigBootstrapper.php

@@ -4,14 +4,19 @@
 
 namespace Stancl\Tenancy\Bootstrappers;
 
+use Illuminate\Broadcasting\Broadcasters\Broadcaster;
 use Illuminate\Broadcasting\BroadcastManager;
 use Illuminate\Config\Repository;
-use Illuminate\Contracts\Broadcasting\Broadcaster;
+use Illuminate\Contracts\Broadcasting\Broadcaster as BroadcasterContract;
 use Illuminate\Foundation\Application;
+use Illuminate\Support\Facades\Broadcast;
 use Stancl\Tenancy\Contracts\TenancyBootstrapper;
 use Stancl\Tenancy\Contracts\Tenant;
-use Stancl\Tenancy\Overrides\TenancyBroadcastManager;
 
+/**
+ * Maps tenant credentials to the broadcasting config and rebinds BroadcastManager
+ * and Broadcaster so that broadcasters get resolved using the tenant credentials.
+ */
 class BroadcastingConfigBootstrapper implements TenancyBootstrapper
 {
     /**
@@ -21,14 +26,16 @@ class BroadcastingConfigBootstrapper implements TenancyBootstrapper
      * [
      *     'config.key.name' => 'tenant_property',
      * ]
+     *
+     * $tenant->tenant_property will be mapped to config('config.key.name') when tenancy is initialized.
      */
     public static array $credentialsMap = [];
 
     public static string|null $broadcaster = null;
 
     protected array $originalConfig = [];
     protected BroadcastManager|null $originalBroadcastManager = null;
-    protected Broadcaster|null $originalBroadcaster = null;
+    protected BroadcasterContract|null $originalBroadcaster = null;
 
     public static array $mapPresets = [
         'pusher' => [
@@ -54,27 +61,85 @@ public function __construct(
         protected Application $app
     ) {
         static::$broadcaster ??= $config->get('broadcasting.default');
-        static::$credentialsMap = array_merge(static::$credentialsMap, static::$mapPresets[static::$broadcaster] ?? []);
+        static::$credentialsMap = array_merge(static::$mapPresets[static::$broadcaster] ?? [], static::$credentialsMap);
     }
 
     public function bootstrap(Tenant $tenant): void
     {
         $this->originalBroadcastManager = $this->app->make(BroadcastManager::class);
-        $this->originalBroadcaster = $this->app->make(Broadcaster::class);
+        $this->originalBroadcaster = $this->app->make(BroadcasterContract::class);
 
         $this->setConfig($tenant);
 
-        // Make BroadcastManager resolve to a custom BroadcastManager which makes the broadcasters use the tenant credentials
-        $this->app->extend(BroadcastManager::class, function (BroadcastManager $broadcastManager) {
-            return new TenancyBroadcastManager($this->app);
+        // Make BroadcastManager resolve to a fresh manager with no cached broadcasters,
+        // so that its broadcasters get resolved using the updated (tenant) broadcasting
+        // config and stay cached for the duration of the tenant's context.
+        $this->app->extend(BroadcastManager::class, function (BroadcastManager $centralManager) {
+            $tenantManager = new BroadcastManager($this->app);
+
+            // Pass the custom driver creators registered in the central context to the new manager
+            // so that custom drivers work in tenant context without having to re-register the creators manually.
+            foreach (invade($centralManager)->customCreators as $driver => $creator) {
+                $tenantManager->extend($driver, $creator);
+            }
+
+            return $tenantManager;
+        });
+
+        // Swap the currently bound Broadcaster singleton (resolved earlier with the central credentials)
+        // for the tenant BroadcastManager's default broadcaster, so that anything resolving the Broadcaster
+        // contract gets the same tenant broadcaster that the manager uses, instead of the stale central one.
+        // The closure runs immediately (the extended singleton is already resolved), and it's also what makes
+        // channel auth work in tenant context -- the broadcaster resolved here gets cached as the tenant
+        // manager's default driver and receives the central broadcaster's auth state (see copyAuthState()).
+        $this->app->extend(BroadcasterContract::class, function (BroadcasterContract $centralBroadcaster) {
+            $tenantBroadcaster = $this->app->make(BroadcastManager::class)->connection();
+
+            $this->copyAuthState($centralBroadcaster, $tenantBroadcaster);
+
+            return $tenantBroadcaster;
         });
+
+        // Extending the binding doesn't update the Broadcast facade's cached instance,
+        // so clear it to make the facade re-resolve to the tenant BroadcastManager instead of the central
+        // one — e.g. in the Broadcast::auth() call in BroadcastController (/broadcasting/auth).
+        Broadcast::clearResolvedInstance();
+    }
+
+    /**
+     * Copy the auth state (the channel auth closures, their options, and the authenticated user
+     * callback) from one broadcaster to another. A freshly resolved broadcaster has no auth state,
+     * so without the copying, channel auth and user auth would stop working (403) in tenant context.
+     *
+     * The auth state is stored on the abstract Broadcaster class, not in the Broadcaster
+     * contract, and it's stored in protected properties. Because of that, we have
+     * to check that both broadcasters are instances of the abstract Broadcaster class and
+     * use invade() to access the protected properties (for the $channels property, there
+     * is a public accessor -- getChannels() -- but since invade is already used here,
+     * we access the property directly for consistency).
+     */
+    protected function copyAuthState(BroadcasterContract $from, BroadcasterContract $to): void
+    {
+        if (! $from instanceof Broadcaster || ! $to instanceof Broadcaster) {
+            return;
+        }
+
+        $fromState = invade($from);
+        $toState = invade($to);
+
+        $toState->channels = $fromState->channels;
+        $toState->channelOptions = $fromState->channelOptions;
+        $toState->authenticatedUserCallback = $fromState->authenticatedUserCallback;
     }
 
     public function revert(): void
     {
-        // Change the BroadcastManager and Broadcaster singletons back to what they were before initializing tenancy
-        $this->app->singleton(BroadcastManager::class, fn (Application $app) => $this->originalBroadcastManager);
-        $this->app->singleton(Broadcaster::class, fn (Application $app) => $this->originalBroadcaster);
+        // Revert the bound BroadcastManager and Broadcaster singletons back to their original state
+        $this->app->instance(BroadcastManager::class, $this->originalBroadcastManager);
+        $this->app->instance(BroadcasterContract::class, $this->originalBroadcaster);
+
+        // Clear the resolved Broadcast facade instance so that it gets re-resolved as the central BroadcastManager
+        Broadcast::clearResolvedInstance();
 
         $this->unsetConfig();
     }

tests/Bootstrappers/BroadcastChannelPrefixBootstrapperTest.php

@@ -16,6 +16,9 @@
 use Stancl\Tenancy\Bootstrappers\DatabaseTenancyBootstrapper;
 use Stancl\Tenancy\Bootstrappers\BroadcastChannelPrefixBootstrapper;
 use function Stancl\Tenancy\Tests\pest;
+use Illuminate\Broadcasting\Broadcasters\NullBroadcaster;
+use Illuminate\Support\Facades\Broadcast;
+use Illuminate\Support\Collection;
 
 beforeEach(function () {
     Event::listen(TenancyInitialized::class, BootstrapTenancy::class);
@@ -137,3 +140,102 @@ protected function formatChannels(array $channels)
     expect(app(BroadcastManager::class)->driver())->toBe($broadcaster);
     expect(invade(app(BroadcastManager::class)->driver())->formatChannels($channelNames))->toEqual($channelNames);
 });
+
+test('broadcasting channel helpers register channels correctly', function() {
+    config([
+        'broadcasting.default' => $driver = 'testing',
+        'broadcasting.connections.testing.driver' => $driver,
+    ]);
+
+    config(['tenancy.bootstrappers' => [DatabaseTenancyBootstrapper::class]]);
+
+    Schema::create('users', function (Blueprint $table) {
+        $table->increments('id');
+        $table->string('name');
+        $table->string('email')->unique();
+        $table->string('password');
+        $table->rememberToken();
+        $table->timestamps();
+    });
+
+    $centralUser = User::create(['name' => 'central', 'email' => 'test@central.cz', 'password' => 'test']);
+    $tenant = Tenant::create();
+
+    migrateTenants();
+
+    tenancy()->initialize($tenant);
+
+    // Same ID as $centralUser
+    $tenantUser = User::create(['name' => 'tenant', 'email' => 'test@tenant.cz', 'password' => 'test']);
+
+    tenancy()->end();
+
+    /** @var BroadcastManager $broadcastManager */
+    $broadcastManager = app(BroadcastManager::class);
+
+    // Use a driver with no channels
+    $broadcastManager->extend($driver, fn () => new NullBroadcaster);
+
+    $getChannels = fn (): Collection => $broadcastManager->driver($driver)->getChannels();
+
+    expect($getChannels())->toBeEmpty();
+
+    // Basic channel registration
+    Broadcast::channel($channelName = 'user.{userName}', $channelClosure = function ($user, $userName) {
+        return User::firstWhere('name', $userName)?->is($user) ?? false;
+    });
+
+    // Check if the channel is registered
+    $centralChannelClosure = $getChannels()->first(fn ($closure, $name) => $name === $channelName);
+    expect($centralChannelClosure)->not()->toBeNull();
+
+    // Channel closures work as expected (running in central context)
+    expect($centralChannelClosure($centralUser, $centralUser->name))->toBeTrue();
+    expect($centralChannelClosure($centralUser, $tenantUser->name))->toBeFalse();
+
+    // Register a tenant broadcasting channel (almost identical to the original channel, just able to accept the tenant key)
+    tenant_channel($channelName, $channelClosure);
+
+    // Tenant channel registered – its name is correctly prefixed ("{tenant}.user.{userName}")
+    $tenantChannelClosure = $getChannels()->first(fn ($closure, $name) => $name === "{tenant}.$channelName");
+    expect($tenantChannelClosure)->toBe($centralChannelClosure);
+
+    // The tenant channels are prefixed with '{tenant}.'
+    // They accept the tenant key, but their closures only run in tenant context when tenancy is initialized
+    // The regular channels don't accept the tenant key, but they also respect the current context
+    // The tenant key is used solely for the name prefixing – the closures can still run in the central context
+    tenant_channel($channelName, $tenantChannelClosure = function ($user, $tenant, $userName) {
+        return User::firstWhere('name', $userName)?->is($user) ?? false;
+    });
+
+    // Retrieve the stored closure to verify that re-registering the channel replaced it
+    // (asserting on $tenantChannelClosure wouldn't tell us what tenant_channel() actually stored)
+    $reregisteredTenantChannelClosure = $getChannels()->first(fn ($closure, $name) => $name === "{tenant}.$channelName");
+
+    expect($reregisteredTenantChannelClosure)
+        ->toBe($tenantChannelClosure)
+        ->not()->toBe($centralChannelClosure);
+
+    expect($reregisteredTenantChannelClosure($centralUser, $tenant->getTenantKey(), $centralUser->name))->toBeTrue();
+    expect($reregisteredTenantChannelClosure($centralUser, $tenant->getTenantKey(), $tenantUser->name))->toBeFalse();
+
+    tenancy()->initialize($tenant);
+
+    // The channel closure runs in the tenant context
+    // Only the tenant user is available
+    expect($tenantChannelClosure($centralUser, $tenant->getTenantKey(), $tenantUser->name))->toBeFalse();
+    expect($tenantChannelClosure($tenantUser, $tenant->getTenantKey(), $tenantUser->name))->toBeTrue();
+
+    // Use a new channel instance to delete the previously registered channels before testing the global_channel helper
+    $broadcastManager->purge($driver);
+    $broadcastManager->extend($driver, fn () => new NullBroadcaster);
+
+    expect($getChannels())->toBeEmpty();
+
+    // Global channel helper prefixes the channel name with 'global__'
+    global_channel($channelName, $channelClosure);
+
+    // Channel prefixed with 'global__' found
+    $foundChannelClosure = $getChannels()->first(fn ($closure, $name) => $name === 'global__' . $channelName);
+    expect($foundChannelClosure)->not()->toBeNull();
+});