feat: let members wait to follow developers who aren't on /dev/null yet

KNOWLEDGE_BASE.md

@@ -133,7 +133,9 @@ Sources: [organization page](resources/js/pages/organization/show.tsx), [commits
 
 Signed in, you can open the address of anyone on GitHub, like `/@octocat`, even if they never signed up. The first time, the page looks the handle up on GitHub while you wait, usually a few seconds, then shows what it found: a developer's page, or an organization's. Each member can look up to 30 handles an hour, since lookups share GitHub's limit with everyone; when that limit runs low, the page says when lookups resume. A handle that is no GitHub account says so, and isn't asked about again for a day. Guests and search engines can't look anyone up: they're asked to sign in.
 
-A developer who isn't here yet gets a page with their GitHub avatar, name, handle, bio and a link to GitHub, marked **Not on /dev/null yet**, but never their location or website. Anyone with the link can open it, and it shares as a card, but search engines are asked to leave it out. Signing in with that GitHub account makes the page yours: guests see an **I am @handle** button for that. If you delete your account, your page doesn't come back as one of these, until you sign in again.
+A developer who isn't here yet gets a page with their GitHub avatar, name, handle, bio and a link to GitHub, marked **Not on /dev/null yet**, but never their location or website. Anyone with the link can open it, and it shares as a card, but search engines are asked to leave it out. Signing in with that GitHub account makes the page yours: guests see an **I am @handle** button for that.
+
+Its page shows how many members are waiting to follow them: the members who followed them on GitHub when they were looked up, and the ones who clicked **Follow** on their page, which then reads **Waiting** and can be clicked again to stop waiting. Members also see the people they follow among them. When the developer signs up, everyone waiting follows them, and their notifications show those follows like any others. Who you wait to follow is in your data export, and goes when you delete your account. If you delete your account, your page doesn't come back as one of these, until you sign in again.
 
 Sources: [looking handles up](app/Http/Controllers/ProfileLookupController.php), [lookup page](resources/js/pages/profile/lookup.tsx), [developer page](resources/js/pages/profile/unclaimed.tsx), [GitHub lookups](app/Actions/CreateGitHubProfile.php).
 

app/Actions/CreateExport.php

@@ -51,7 +51,7 @@
  *     dismissed_suggestions: Generator<int, ExportUser>,
  *     organizations: array<int, array{handle: string, role: string, joined_at: string}>,
  *     followed_organizations: array<int, array{handle: string, followed_at: string}>,
- *     pending_organization_follows: list<string>,
+ *     pending_follows: list<string>,
  *     messages: Generator<int, ExportMessage>,
  *     reports: Traversable<int, array<string, mixed>>,
  *     remote_pins: array<int, array{to: string|null, pinned_at: string|null}>,
@@ -74,7 +74,7 @@
     public function handle(User $user): array
     {
         return [
-            'schema_version' => 5,
+            'schema_version' => 6,
             'exported_at' => now()->toIso8601String(),
             'profile' => [
                 'github_id' => $user->github_id,
@@ -123,7 +123,7 @@ public function handle(User $user): array
             'dismissed_suggestions' => $this->handles($user->dismissedSuggestions()),
             'organizations' => $this->organizations($user),
             'followed_organizations' => $this->followedOrganizations($user),
-            'pending_organization_follows' => $this->pendingOrganizationFollows($user),
+            'pending_follows' => $this->pendingFollows($user),
             'messages' => $this->messages($user),
             'reports' => CommitReport::query()->where('reporter_id', $user->id)->oldest('id')->cursor()->map(fn (CommitReport $report): array => [
                 'commit_id' => $report->commit_id,
@@ -397,14 +397,14 @@ private function followedOrganizations(User $user): array
     }
 
     /**
-     * The GitHub IDs of the organizations the user follows on GitHub, to follow here once they are on /dev/null.
+     * The GitHub IDs of the accounts the user waits to follow until they are on /dev/null: organizations and developers.
      *
      * @return list<string>
      */
-    private function pendingOrganizationFollows(User $user): array
+    private function pendingFollows(User $user): array
     {
         /** @var list<string> */
-        return DB::table('pending_organization_follows')->where('user_id', $user->id)->orderBy('github_id')->pluck('github_id')->all();
+        return DB::table('pending_follows')->where('user_id', $user->id)->orderBy('github_id')->pluck('github_id')->all();
     }
 
     /**

app/Actions/CreateFollowsFromPendingFollows.php

@@ -0,0 +1,34 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Actions;
+
+use App\Models\User;
+use Illuminate\Support\Facades\DB;
+
+final readonly class CreateFollowsFromPendingFollows
+{
+    public function __construct(private CreateFollowNotification $createFollowNotification)
+    {
+        //
+    }
+
+    /**
+     * The members who waited for a developer to sign up follow them once they do, each with the usual follow
+     * notification, which their inbox groups into one. A new user has no followers yet, so none follows twice.
+     */
+    public function handle(User $user): void
+    {
+        $pending = DB::table('pending_follows')->where('github_id', $user->github_id);
+        $followers = User::query()->whereIn('id', $pending->clone()->select('user_id'))->get();
+
+        $user->followers()->attach($followers->modelKeys());
+
+        foreach ($followers as $follower) {
+            $this->createFollowNotification->handle($follower, $user);
+        }
+
+        $pending->delete();
+    }
+}

app/Actions/CreateGitHubProfile.php

@@ -25,9 +25,9 @@ public function __construct(
 
     /**
      * Gives the handle a page from its GitHub account: an organization's, or an unclaimed developer's, which keeps only
-     * what the page shows. A user here who renamed on GitHub moves to the handle. A handle that is no GitHub account,
-     * or the account of someone who deleted theirs here, is remembered for a day, so the page says so without asking
-     * GitHub again.
+     * what the page shows, with the members following them on GitHub waiting to follow them here. A user here who
+     * renamed on GitHub moves to the handle. A handle that is no GitHub account, or the account of someone who deleted
+     * theirs here, is remembered for a day, so the page says so without asking GitHub again.
      */
     public function handle(string $handle): void
     {
@@ -50,7 +50,12 @@ public function handle(string $handle): void
 
         $profile = GitHubProfile::fromAccount($account);
 
-        DB::transaction(function () use ($profile, $githubId): void {
+        // Asked before the profile exists, so a sign-in can't come between them and miss the members waiting...
+        $followerIds = Profile::query()->where('github_id', $githubId)->exists()
+            ? []
+            : $this->github->followerIds($profile->handle, CreateUserGitHubFollows::MaxPages);
+
+        DB::transaction(function () use ($profile, $githubId, $followerIds): void {
             $this->updateStaleHandles->handle($profile->handle, $githubId);
 
             $existing = Profile::query()->where('type', ProfileType::User)->firstWhere('github_id', $githubId);
@@ -69,6 +74,12 @@ public function handle(string $handle): void
                 'bio' => $profile->bio,
                 'github_synced_at' => now(),
             ]);
+
+            // Those still waiting from before the profile last went are kept...
+            DB::table('pending_follows')->insertOrIgnoreUsing(
+                ['user_id', 'github_id', 'created_at'],
+                User::query()->whereIn('github_id', $followerIds)->select('id')->selectRaw('?, ?', [$githubId, now()]),
+            );
         });
     }
 }

app/Actions/CreatePendingFollow.php

@@ -0,0 +1,28 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Actions;
+
+use App\Models\Profile;
+use App\Models\User;
+use Illuminate\Support\Facades\DB;
+
+final readonly class CreatePendingFollow
+{
+    /**
+     * The user follows the developer once they sign up. Waiting twice is waiting once. The profile is locked, as signing
+     * up turns the waits into follows under its lock: a wait for someone who just signed up is dropped rather than left
+     * behind.
+     */
+    public function handle(User $user, Profile $profile): void
+    {
+        DB::transaction(function () use ($user, $profile): void {
+            if (Profile::query()->lockForUpdate()->find($profile->id)?->isUnclaimed() !== true) {
+                return;
+            }
+
+            DB::table('pending_follows')->insertOrIgnore(['user_id' => $user->id, 'github_id' => $profile->github_id, 'created_at' => now()]);
+        });
+    }
+}

app/Actions/CreateUserGitHubFollows.php

@@ -69,7 +69,7 @@ public function handle(User $user, bool $notify = true): void
 
                 $user->followedOrganizations()->syncWithoutDetaching($organizations->modelKeys());
 
-                DB::table('pending_organization_follows')->insertOrIgnore($organizationIds
+                DB::table('pending_follows')->insertOrIgnore($organizationIds
                     ->reject(fn (string $id): bool => $organizations->contains('github_id', $id))
                     ->map(fn (string $id): array => ['user_id' => $user->id, 'github_id' => $id, 'created_at' => now()])
                     ->all());

app/Actions/DeletePendingFollow.php

@@ -0,0 +1,20 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Actions;
+
+use App\Models\Profile;
+use App\Models\User;
+use Illuminate\Support\Facades\DB;
+
+final readonly class DeletePendingFollow
+{
+    /**
+     * The user no longer follows the developer when they sign up, whether they waited from their page or from GitHub.
+     */
+    public function handle(User $user, Profile $profile): void
+    {
+        DB::table('pending_follows')->where('user_id', $user->id)->where('github_id', $profile->github_id)->delete();
+    }
+}

app/Actions/UpdateOrCreateOrganization.php

@@ -52,7 +52,7 @@ public function handle(array $account): Organization
             $organization = Organization::query()->firstOrCreate(['id' => $organizationProfile->id]);
 
             if ($organization->wasRecentlyCreated) {
-                $pending = DB::table('pending_organization_follows')->where('github_id', (string) $githubId);
+                $pending = DB::table('pending_follows')->where('github_id', (string) $githubId);
 
                 DB::table('organization_follows')->insertUsing(
                     ['user_id', 'organization_id', 'created_at'],

app/Actions/UpdateOrCreateUser.php

@@ -14,14 +14,18 @@
 
 final readonly class UpdateOrCreateUser
 {
-    public function __construct(private GitHubProvider $github, private UpdateStaleHandles $updateStaleHandles)
-    {
+    public function __construct(
+        private GitHubProvider $github,
+        private UpdateStaleHandles $updateStaleHandles,
+        private CreateFollowsFromPendingFollows $createFollowsFromPendingFollows,
+    ) {
         //
     }
 
     /**
      * Signing in makes the GitHub account's profile a user's: an unclaimed one, looked up from GitHub before, becomes
-     * theirs with its ID. Someone who deleted their account and comes back is no longer remembered as gone.
+     * theirs with its ID, and the members waiting for them follow them. Someone who deleted their account and comes back
+     * is no longer remembered as gone.
      */
     public function handle(GitHubUser $githubUser): User
     {
@@ -46,14 +50,20 @@ public function handle(GitHubUser $githubUser): User
 
             DB::table('deleted_github_accounts')->where('github_id', $githubId)->delete();
 
-            return User::query()->updateOrCreate([
+            $user = User::query()->updateOrCreate([
                 'id' => $id,
                 'github_id' => $githubId,
             ], [
                 'company' => $profile->company,
                 'email' => $email === '' ? null : $email,
                 ...($hasSponsorsListing === null ? [] : ['has_sponsors_listing' => $hasSponsorsListing]),
             ]);
+
+            if ($user->wasRecentlyCreated) {
+                $this->createFollowsFromPendingFollows->handle($user);
+            }
+
+            return $user;
         });
     }
 }

app/Actions/UpdateStaleHandles.php

@@ -13,7 +13,7 @@
      * placeholder starts with an underscore, which no GitHub handle can, and their next sync restores a real one.
      * Bots keep their identity under reserved handles so they can continue replying. An unclaimed profile, a developer
      * looked up from GitHub who never signed in, has nothing of its own, so it goes: looking its new handle up brings it
-     * back.
+     * back, with the members waiting for it, kept by its GitHub ID.
      */
     public function handle(string $handle, string $githubId): void
     {

app/Http/Controllers/PendingFollowController.php

@@ -0,0 +1,34 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Http\Controllers;
+
+use App\Actions\CreatePendingFollow;
+use App\Actions\DeletePendingFollow;
+use App\Http\Requests\CreatePendingFollowRequest;
+use App\Http\Requests\DeletePendingFollowRequest;
+use App\Models\Profile;
+use App\Models\User;
+use Illuminate\Container\Attributes\CurrentUser;
+use Illuminate\Http\RedirectResponse;
+
+/**
+ * Following a developer who isn't on /dev/null yet waits for them to sign up.
+ */
+final readonly class PendingFollowController
+{
+    public function store(CreatePendingFollowRequest $request, #[CurrentUser] User $user, Profile $profile, CreatePendingFollow $action): RedirectResponse
+    {
+        $action->handle($user, $profile);
+
+        return back();
+    }
+
+    public function destroy(DeletePendingFollowRequest $request, #[CurrentUser] User $user, Profile $profile, DeletePendingFollow $action): RedirectResponse
+    {
+        $action->handle($user, $profile);
+
+        return back();
+    }
+}

app/Http/Controllers/UnclaimedProfileController.php

@@ -10,15 +10,16 @@
 use App\Services\PageMetadata;
 use Illuminate\Container\Attributes\CurrentUser;
 use Illuminate\Http\RedirectResponse;
+use Illuminate\Support\Facades\DB;
 use Inertia\Inertia;
 use Inertia\Response;
 
 final readonly class UnclaimedProfileController
 {
     /**
      * A developer looked up from GitHub who isn't on /dev/null yet has a page at their "@handle", with what GitHub
-     * shows of them but where they are, for anyone with the link, but kept out of search engines. Signing in as them
-     * makes it theirs. Like users' pages, it moves for good to the handle's own case.
+     * shows of them but where they are, for anyone with the link, but kept out of search engines, with how many members
+     * wait to follow them. Signing in as them makes it theirs. Like users' pages, it moves for good to the handle's own case.
      */
     public function show(ShowUnclaimedProfileRequest $request, #[CurrentUser] ?User $currentUser, PageMetadata $metadata): RedirectResponse|Response
     {
@@ -32,8 +33,20 @@ public function show(ShowUnclaimedProfileRequest $request, #[CurrentUser] ?User
             return redirect(route('user.show', $profile->handle).($query === '' ? '' : "?{$query}"), 301, ['Cache-Control' => 'max-age=86400, private']);
         }
 
+        $waiting = DB::table('pending_follows')->where('github_id', $profile->github_id);
+
         return Inertia::render('profile/unclaimed', [
-            'profile' => $profile->only(['handle', 'name', 'avatar_url', 'bio']),
+            'profile' => $profile->only(['id', 'handle', 'name', 'avatar_url', 'bio']),
+            'waitingCount' => fn (): int => $waiting->clone()->count(),
+            'isWaiting' => fn (): bool => $currentUser instanceof User && $waiting->clone()->where('user_id', $currentUser->id)->exists(),
+            // Who follows whom is for members, so only they see who is waiting, among the people they follow...
+            'waitingYouFollow' => fn (): array => $currentUser instanceof User ? $currentUser->following()
+                ->whereIn('users.id', $waiting->clone()->select('user_id'))
+                ->orderBy('users.id')
+                ->limit(3)
+                ->get()
+                ->map(fn (User $user): array => $user->only(['id', 'handle', 'name', 'avatar_url']))
+                ->all() : [],
         ])->withViewData(['preview' => $currentUser instanceof User || $request->inertia() ? null : $metadata->unclaimedProfile($profile)]);
     }
 }

app/Http/Requests/CreatePendingFollowRequest.php

@@ -0,0 +1,31 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Http\Requests;
+
+use App\Models\Profile;
+use Illuminate\Auth\Access\Response;
+use Illuminate\Foundation\Http\FormRequest;
+
+final class CreatePendingFollowRequest extends FormRequest
+{
+    /**
+     * Only a developer who isn't on /dev/null yet is waited for: once they are, members follow them.
+     */
+    public function authorize(): Response
+    {
+        $profile = $this->route('profile');
+        assert($profile instanceof Profile);
+
+        return $profile->isUnclaimed() ? Response::allow() : Response::denyAsNotFound();
+    }
+
+    /**
+     * @return array{}
+     */
+    public function rules(): array
+    {
+        return [];
+    }
+}

app/Http/Requests/DeletePendingFollowRequest.php

@@ -0,0 +1,31 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Http\Requests;
+
+use App\Models\Profile;
+use Illuminate\Auth\Access\Response;
+use Illuminate\Foundation\Http\FormRequest;
+
+final class DeletePendingFollowRequest extends FormRequest
+{
+    /**
+     * Only a developer who isn't on /dev/null yet is waited for: once they are, members follow them.
+     */
+    public function authorize(): Response
+    {
+        $profile = $this->route('profile');
+        assert($profile instanceof Profile);
+
+        return $profile->isUnclaimed() ? Response::allow() : Response::denyAsNotFound();
+    }
+
+    /**
+     * @return array{}
+     */
+    public function rules(): array
+    {
+        return [];
+    }
+}