Allow account owners to delete workspaces

app/Actions/Account/CancelAccountSubscription.php

@@ -0,0 +1,38 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Actions\Account;
+
+use App\Models\Account;
+use Illuminate\Support\Facades\Log;
+use Throwable;
+
+class CancelAccountSubscription
+{
+    /**
+     * Cancel the non-ended named Stripe subscription for an account before
+     * local teardown.
+     *
+     * @return bool false when Stripe cancel fails (nothing local should be deleted)
+     */
+    public static function execute(Account $account): bool
+    {
+        try {
+            $subscription = $account->subscription(Account::SUBSCRIPTION_NAME);
+
+            if ($subscription && ! $subscription->ended()) {
+                $subscription->cancelNow();
+            }
+
+            return true;
+        } catch (Throwable $e) {
+            Log::warning('Failed to cancel Stripe subscription during account delete', [
+                'account_id' => $account->id,
+                'error' => $e->getMessage(),
+            ]);
+
+            return false;
+        }
+    }
+}

app/Actions/Auth/LogoutAndInvalidateSession.php

@@ -0,0 +1,34 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Actions\Auth;
+
+use Illuminate\Http\Request;
+use Illuminate\Support\Facades\Auth;
+
+class LogoutAndInvalidateSession
+{
+    /**
+     * Log the user out while the row still exists, then invalidate the session.
+     * SessionGuard cycles the remember token via save() — calling this after
+     * $user->delete() can re-insert the deleted user.
+     *
+     * @param  array{banner?: string|null, bannerStyle?: string|null}|null  $reflash
+     */
+    public static function execute(?Request $request = null, ?array $reflash = null): void
+    {
+        $request ??= request();
+
+        Auth::logout();
+        $request->session()->invalidate();
+        $request->session()->regenerateToken();
+
+        $banner = data_get($reflash, 'banner');
+
+        if ($banner !== null) {
+            session()->flash('flash.banner', $banner);
+            session()->flash('flash.bannerStyle', data_get($reflash, 'bannerStyle', 'info'));
+        }
+    }
+}

app/Actions/Invite/AcceptInvite.php

@@ -0,0 +1,84 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Actions\Invite;
+
+use App\Actions\Account\CancelAccountSubscription;
+use App\Enums\Invite\Result;
+use App\Models\Account;
+use App\Models\Invite;
+use App\Models\User;
+use Illuminate\Support\Facades\DB;
+
+class AcceptInvite
+{
+    public static function execute(User $user, Invite $invite): Result
+    {
+        if ($invite->email !== $user->email) {
+            return Result::WrongEmail;
+        }
+
+        $previousAccountId = null;
+
+        $result = DB::transaction(function () use ($user, $invite, &$previousAccountId): Result {
+            $lockedInvite = Invite::query()
+                ->whereKey($invite->id)
+                ->lockForUpdate()
+                ->first();
+
+            if (! $lockedInvite) {
+                return Result::Gone;
+            }
+
+            if ($lockedInvite->accepted_at !== null) {
+                return Result::AlreadyAccepted;
+            }
+
+            $workspaces = ResolveInviteWorkspaces::execute($lockedInvite);
+
+            if ($workspaces->isEmpty()) {
+                $lockedInvite->delete();
+
+                return Result::Gone;
+            }
+
+            // Already on the account: still attach any missing workspace memberships.
+            if ($user->account_id === $lockedInvite->account_id) {
+                AttachInviteWorkspaces::execute($user, $lockedInvite, $workspaces);
+
+                $lockedInvite->update(['accepted_at' => now()]);
+
+                return Result::AlreadyMember;
+            }
+
+            $previousAccountId = $user->account_id;
+
+            $user->update(['account_id' => $lockedInvite->account_id]);
+            $user->refresh();
+
+            AttachInviteWorkspaces::execute($user, $lockedInvite, $workspaces);
+
+            $lockedInvite->update(['accepted_at' => now()]);
+
+            return Result::Accepted;
+        });
+
+        // Invite signup leaves an empty personal account shell. Drop it after
+        // commit so Stripe cancel is not held inside the invite lock. Members
+        // never own a non-empty account, so there is nothing else to tear down.
+        if ($result === Result::Accepted && $previousAccountId) {
+            $shell = Account::query()
+                ->whereKey($previousAccountId)
+                ->where('owner_id', $user->id)
+                ->whereDoesntHave('workspaces')
+                ->first();
+
+            if ($shell && CancelAccountSubscription::execute($shell)) {
+                $shell->delete();
+            }
+        }
+
+        return $result;
+    }
+}

app/Actions/Invite/AttachInviteWorkspaces.php

@@ -0,0 +1,51 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Actions\Invite;
+
+use App\Models\Invite;
+use App\Models\User;
+use App\Models\Workspace;
+use Illuminate\Support\Collection;
+
+class AttachInviteWorkspaces
+{
+    /**
+     * @param  Collection<int, Workspace>  $workspaces
+     */
+    public static function execute(User $user, Invite $invite, Collection $workspaces): void
+    {
+        foreach ($workspaces as $workspace) {
+            $alreadyMember = $workspace->members()
+                ->where('users.id', $user->id)
+                ->exists();
+
+            // Never overwrite an existing pivot role (avoids demoting admins).
+            if (! $alreadyMember) {
+                $workspace->members()->attach($user->id, [
+                    'role' => $invite->role->value,
+                ]);
+            }
+
+            // Accept often switches account_id while an old personal workspace is
+            // still current — always land on a workspace of the invite account.
+            if (! self::currentWorkspaceBelongsToAccount($user)) {
+                $user->update(['current_workspace_id' => $workspace->id]);
+                $user->refresh();
+            }
+        }
+    }
+
+    public static function currentWorkspaceBelongsToAccount(User $user): bool
+    {
+        if (! $user->current_workspace_id || ! $user->account_id) {
+            return false;
+        }
+
+        return $user->workspaces()
+            ->where('workspaces.id', $user->current_workspace_id)
+            ->where('workspaces.account_id', $user->account_id)
+            ->exists();
+    }
+}

app/Actions/Invite/DeclineInvite.php

@@ -0,0 +1,38 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Actions\Invite;
+
+use App\Enums\Invite\Result;
+use App\Models\Invite;
+use App\Models\User;
+use Illuminate\Support\Facades\DB;
+
+class DeclineInvite
+{
+    public static function execute(User $user, Invite $invite): Result
+    {
+        if ($invite->email !== $user->email) {
+            return Result::WrongEmail;
+        }
+
+        $workspacesGone = DB::transaction(function () use ($invite): bool {
+            $lockedInvite = Invite::query()
+                ->whereKey($invite->id)
+                ->lockForUpdate()
+                ->first();
+
+            if (! $lockedInvite) {
+                return true;
+            }
+
+            $workspaces = ResolveInviteWorkspaces::execute($lockedInvite);
+            $lockedInvite->delete();
+
+            return $workspaces->isEmpty();
+        });
+
+        return $workspacesGone ? Result::Gone : Result::Declined;
+    }
+}

app/Actions/Invite/RemoveMember.php

@@ -4,12 +4,54 @@
 
 namespace App\Actions\Invite;
 
+use App\Actions\User\ReassignCurrentWorkspace;
+use App\Actions\User\SettleStrandedMember;
+use App\Actions\User\StrandedSettlement;
+use App\Models\Account;
+use App\Models\User;
 use App\Models\Workspace;
+use Illuminate\Support\Facades\DB;
 
 class RemoveMember
 {
     public static function execute(Workspace $workspace, string $userId): void
     {
-        $workspace->members()->detach($userId);
+        $settlement = StrandedSettlement::none();
+
+        DB::transaction(function () use ($workspace, $userId, &$settlement): void {
+            $account = $workspace->account;
+
+            // Serialize with DeleteWorkspace / other RemoveMember calls on this
+            // account so concurrent removals cannot skip stranded cleanup.
+            if ($account?->id) {
+                Account::query()->whereKey($account->id)->lockForUpdate()->first();
+            }
+
+            $user = User::query()->find($userId);
+
+            $workspace->members()->detach($userId);
+
+            if (! $user) {
+                return;
+            }
+
+            $user->refresh();
+
+            if ($user->current_workspace_id === $workspace->id) {
+                ReassignCurrentWorkspace::forUserAwayFrom($user, $workspace);
+                $user->refresh();
+            }
+
+            // Last membership on this shared account — delete the invitee.
+            if (
+                $account
+                && $user->account_id === $account->id
+                && $user->id !== $account->owner_id
+            ) {
+                $settlement = SettleStrandedMember::execute($user, $account);
+            }
+        });
+
+        $settlement->flush();
     }
 }

app/Actions/Invite/ResolveInviteWorkspaces.php

@@ -0,0 +1,34 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Actions\Invite;
+
+use App\Models\Invite;
+use App\Models\Workspace;
+use Illuminate\Support\Collection;
+
+class ResolveInviteWorkspaces
+{
+    /**
+     * Workspaces listed on the invite that still exist on the invite's account.
+     *
+     * @return Collection<int, Workspace>
+     */
+    public static function execute(Invite $invite): Collection
+    {
+        $ids = collect(data_get($invite, 'workspaces', []))
+            ->filter()
+            ->values()
+            ->all();
+
+        if ($ids === []) {
+            return collect();
+        }
+
+        return Workspace::query()
+            ->whereIn('id', $ids)
+            ->where('account_id', $invite->account_id)
+            ->get();
+    }
+}