Log in subscribers when broadcasting a subscription update

composer.json

@@ -25,6 +25,7 @@
     "require": {
         "php": ">= 7.1",
         "ext-json": "*",
+        "illuminate/auth": "5.5.* || 5.6.* || 5.7.* || 5.8.* || ^6.0 || ^7.0",
         "illuminate/contracts": "5.5.* || 5.6.* || 5.7.* || 5.8.* || ^6.0 || ^7.0",
         "illuminate/http": "5.5.* || 5.6.* || 5.7.* || 5.8.* || ^6.0 || ^7.0",
         "illuminate/pagination": "5.5.* || 5.6.* || 5.7.* || 5.8.* || ^6.0 || ^7.0",

src/Subscriptions/Contracts/SubscriptionIterator.php

@@ -8,9 +8,18 @@
 interface SubscriptionIterator
 {
     /**
-     * Process collection of items.
+     * Process subscribers.
      *
+     * @param  \Illuminate\Support\Collection<\Nuwave\Lighthouse\Subscriptions\Subscriber>  $subscribers
+     * The subscribers that receive the current subscription.
+     *
+     * @param  \Closure  $handleSubscriber
+     * Receives each subscriber in the passed in collection.
+     * function(\Nuwave\Lighthouse\Subscriptions\Subscriber $subscriber)
+     *
+     * @param  \Closure|null  $onError
+     * Is called when $handleSubscriber throws.
      * @return void
      */
-    public function process(Collection $items, Closure $cb, Closure $error = null);
+    public function process(Collection $subscribers, Closure $handleSubscriber, Closure $onError = null);
 }

src/Subscriptions/Iterators/GuardContextSyncIterator.php

@@ -0,0 +1,66 @@
+<?php
+
+namespace Nuwave\Lighthouse\Subscriptions\Iterators;
+
+use Closure;
+use Exception;
+use Illuminate\Contracts\Auth\Factory;
+use Illuminate\Contracts\Config\Repository;
+use Illuminate\Support\Collection;
+use Nuwave\Lighthouse\Subscriptions\Contracts\SubscriptionIterator;
+use Nuwave\Lighthouse\Subscriptions\Subscriber;
+use Nuwave\Lighthouse\Subscriptions\SubscriptionGuard;
+
+class GuardContextSyncIterator implements SubscriptionIterator
+{
+    /**
+     * @var \Illuminate\Contracts\Config\Repository
+     */
+    private $configRepository;
+
+    /**
+     * @var \Illuminate\Contracts\Auth\Factory
+     */
+    private $authFactory;
+
+    public function __construct(Repository $configRepository, Factory $authFactory)
+    {
+        $this->authFactory = $authFactory;
+        $this->configRepository = $configRepository;
+    }
+
+    public function process(Collection $subscribers, Closure $handleSubscriber, Closure $onError = null): void
+    {
+        // Store the previous default guard name so we can restore it after we're done
+        $previousGuardName = $this->configRepository->get('auth.defaults.guard');
+
+        // Set our subscription guard as the default guard for the application
+        $this->authFactory->shouldUse(SubscriptionGuard::GUARD_NAME);
+
+        /** @var \Nuwave\Lighthouse\Subscriptions\SubscriptionGuard $guard */
+        $guard = $this->authFactory->guard(SubscriptionGuard::GUARD_NAME);
+
+        $subscribers->each(static function (Subscriber $item) use ($handleSubscriber, $onError, $guard): void {
+            // If there is an authenticated user set in the context, set that user as the authenticated user
+            if ($item->context->user()) {
+                $guard->setUser($item->context->user());
+            }
+
+            try {
+                $handleSubscriber($item);
+            } catch (Exception $e) {
+                if (! $onError) {
+                    throw $e;
+                }
+
+                $onError($e);
+            } finally {
+                // Unset the authenticated user after each iteration to restore the guard to a unauthenticated state
+                $guard->reset();
+            }
+        });
+
+        // Restore the previous default guard name
+        $this->authFactory->shouldUse($previousGuardName);
+    }
+}

src/Subscriptions/Iterators/SyncIterator.php

@@ -9,20 +9,17 @@
 
 class SyncIterator implements SubscriptionIterator
 {
-    /**
-     * Process collection of items.
-     */
-    public function process(Collection $items, Closure $cb, Closure $error = null): void
+    public function process(Collection $subscribers, Closure $handleSubscriber, Closure $onError = null): void
     {
-        $items->each(function ($item) use ($cb, $error): void {
+        $subscribers->each(static function ($item) use ($handleSubscriber, $onError): void {
             try {
-                $cb($item);
+                $handleSubscriber($item);
             } catch (Exception $e) {
-                if (! $error) {
+                if (! $onError) {
                     throw $e;
                 }
 
-                $error($e);
+                $onError($e);
             }
         });
     }

src/Subscriptions/SubscriptionGuard.php

@@ -0,0 +1,29 @@
+<?php
+
+namespace Nuwave\Lighthouse\Subscriptions;
+
+use Illuminate\Auth\GuardHelpers;
+use Illuminate\Contracts\Auth\Guard;
+use RuntimeException;
+
+class SubscriptionGuard implements Guard
+{
+    use GuardHelpers;
+
+    public const GUARD_NAME = 'lighthouse_subscriptions';
+
+    public function user()
+    {
+        return $this->user;
+    }
+
+    public function reset()
+    {
+        $this->user = null;
+    }
+
+    public function validate(array $credentials = [])
+    {
+        throw new RuntimeException('The Lighthouse subscription guard cannot be used for credential based authentication.');
+    }
+}

src/Subscriptions/SubscriptionServiceProvider.php

@@ -2,6 +2,7 @@
 
 namespace Nuwave\Lighthouse\Subscriptions;
 
+use Illuminate\Auth\AuthManager;
 use Illuminate\Contracts\Config\Repository as ConfigRepository;
 use Illuminate\Contracts\Events\Dispatcher as EventsDispatcher;
 use Illuminate\Support\ServiceProvider;
@@ -16,6 +17,7 @@
 use Nuwave\Lighthouse\Subscriptions\Contracts\SubscriptionIterator;
 use Nuwave\Lighthouse\Subscriptions\Events\BroadcastSubscriptionEvent;
 use Nuwave\Lighthouse\Subscriptions\Events\BroadcastSubscriptionListener;
+use Nuwave\Lighthouse\Subscriptions\Iterators\GuardContextSyncIterator;
 use Nuwave\Lighthouse\Subscriptions\Iterators\SyncIterator;
 use Nuwave\Lighthouse\Support\Contracts\ProvidesSubscriptionResolver;
 
@@ -50,6 +52,21 @@ public function boot(EventsDispatcher $eventsDispatcher, ConfigRepository $confi
                 $this->app->make('router')
             );
         }
+
+        // Test if the auth manager is bound to the container before using it in case the application is not using any authentication
+        if ($this->app->bound(AuthManager::class)) {
+            config([
+                'auth.guards.'.SubscriptionGuard::GUARD_NAME => [
+                    'driver' => SubscriptionGuard::GUARD_NAME,
+                ],
+            ]);
+
+            $this->app->bind(SubscriptionIterator::class, GuardContextSyncIterator::class);
+
+            $this->app->make(AuthManager::class)->extend(SubscriptionGuard::GUARD_NAME, static function () {
+                return new SubscriptionGuard;
+            });
+        }
     }
 
     /**

tests/Unit/Subscriptions/BroadcastManagerTest.php

@@ -9,24 +9,14 @@
 use Nuwave\Lighthouse\Subscriptions\BroadcastManager;
 use Nuwave\Lighthouse\Subscriptions\Contracts\Broadcaster;
 use Nuwave\Lighthouse\Subscriptions\Subscriber;
-use Nuwave\Lighthouse\Subscriptions\SubscriptionServiceProvider;
-use Tests\TestCase;
 
-class BroadcastManagerTest extends TestCase
+class BroadcastManagerTest extends SubscriptionTestCase
 {
     /**
      * @var \Nuwave\Lighthouse\Subscriptions\BroadcastManager
      */
     protected $broadcastManager;
 
-    protected function getPackageProviders($app)
-    {
-        return array_merge(
-            parent::getPackageProviders($app),
-            [SubscriptionServiceProvider::class]
-        );
-    }
-
     /**
      * Set up test environment.
      */

tests/Unit/Subscriptions/Iterators/GuardContextSyncIteratorTest.php

@@ -0,0 +1,173 @@
+<?php
+
+namespace Tests\Unit\Subscriptions\Iterators;
+
+use Exception;
+use GraphQL\Type\Definition\ResolveInfo;
+use Illuminate\Auth\AuthManager;
+use Illuminate\Contracts\Auth\Authenticatable;
+use Illuminate\Http\Request;
+use Illuminate\Support\Collection;
+use Mockery\MockInterface;
+use Nuwave\Lighthouse\Schema\Context;
+use Nuwave\Lighthouse\Subscriptions\Iterators\GuardContextSyncIterator;
+use Nuwave\Lighthouse\Subscriptions\Subscriber;
+use Nuwave\Lighthouse\Subscriptions\SubscriptionGuard;
+use Tests\Unit\Subscriptions\SubscriptionTestCase;
+
+class GuardContextSyncIteratorTest extends SubscriptionTestCase
+{
+    /**
+     * @var string
+     */
+    public const EXCEPTION_MESSAGE = 'test_exception';
+
+    /**
+     * @var \Nuwave\Lighthouse\Subscriptions\Iterators\GuardContextSyncIterator
+     */
+    protected $iterator;
+
+    protected function setUp(): void
+    {
+        parent::setUp();
+
+        $this->iterator = $this->app->make(GuardContextSyncIterator::class);
+    }
+
+    public function testCanIterateOverItemsWithCallback(): void
+    {
+        $items = [];
+
+        $this->iterator->process(
+            $this->subscribers(),
+            static function ($item) use (&$items): void {
+                $items[] = $item;
+            }
+        );
+
+        $this->assertCount(3, $items);
+    }
+
+    public function testCanPassExceptionToHandler(): void
+    {
+        /** @var \Exception|null $exception */
+        $exception = null;
+
+        $this->iterator->process(
+            $this->subscribers(),
+            static function (): void {
+                throw new Exception(self::EXCEPTION_MESSAGE);
+            },
+            static function (Exception $e) use (&$exception): void {
+                $exception = $e;
+            }
+        );
+
+        $this->assertSame(self::EXCEPTION_MESSAGE, $exception->getMessage());
+    }
+
+    public function testSetsAndResetsGuardContextAfterEachIteration(): void
+    {
+        // Give each subscriber a user stub and an ID based on the index of the subscriber in the collection
+        $subscribers = $this->subscribers()->map(static function (Subscriber $subscriber, int $index) {
+            $subscriber->context->user = new GuardContextSyncIteratorAuthenticatableStub($index + 1);
+
+            return $subscriber;
+        });
+
+        $guard = $this->mock(SubscriptionGuard::class, static function (MockInterface $mock) use ($subscribers) {
+            $subscribers->each(static function (Subscriber $subscriber) use ($mock) {
+                $mock->shouldReceive('setUser')->with($subscriber->context->user())->once();
+                $mock->shouldReceive('user')->andReturn($subscriber->context->user())->once();
+                $mock->shouldReceive('reset')->once();
+            });
+        });
+
+        $authManager = $this->app->make(AuthManager::class);
+
+        $authManager->extend(SubscriptionGuard::GUARD_NAME, static function () use ($guard) {
+            return $guard;
+        });
+
+        $processedItems = [];
+        $authenticatedUser = [];
+        $guardBeforeIteration = $authManager->guard();
+
+        $this->iterator->process(
+            $subscribers,
+            static function (Subscriber $subscriber) use (&$processedItems, &$authenticatedUser, $authManager): void {
+                $processedItems[] = $subscriber;
+                $authenticatedUser[] = $authManager->user();
+            }
+        );
+
+        $this->assertCount(3, $processedItems);
+        $this->assertSame($subscribers->pluck('context.user')->all(), $authenticatedUser);
+        $this->assertSame($guardBeforeIteration, $authManager->guard());
+    }
+
+    /**
+     * @return \Illuminate\Support\Collection<\Nuwave\Lighthouse\Subscriptions\Subscriber>
+     */
+    protected function subscribers(): Collection
+    {
+        return new Collection([
+            $this->generateSubscriber(),
+            $this->generateSubscriber(),
+            $this->generateSubscriber(),
+        ]);
+    }
+
+    private function generateSubscriber(): Subscriber
+    {
+        $resolveInfo = $this->getMockBuilder(ResolveInfo::class)
+            ->disableOriginalConstructor()
+            ->getMock();
+
+        $resolveInfo->operation = (object)[
+            'name' => (object)[
+                'value' => 'lighthouse',
+            ],
+        ];
+
+        return new Subscriber([], new Context(new Request), $resolveInfo);
+    }
+}
+
+class GuardContextSyncIteratorAuthenticatableStub implements Authenticatable
+{
+    /**
+     * @var int
+     */
+    private $id;
+
+    public function __construct(int $id)
+    {
+        $this->id = $id;
+    }
+
+    public function getAuthIdentifierName()
+    {
+    }
+
+    public function getAuthIdentifier()
+    {
+        return $this->id;
+    }
+
+    public function getAuthPassword()
+    {
+    }
+
+    public function getRememberToken()
+    {
+    }
+
+    public function setRememberToken($value)
+    {
+    }
+
+    public function getRememberTokenName()
+    {
+    }
+}