Add plugin purchase refund system

simonhamp · claude · simonhamp · commit d624cf56a7f1 · 2026-04-10T00:26:08.000+01:00
Adds ability for admins to refund plugin purchases from Filament,
including Stripe refund, license revocation, and payout cancellation.

Co-Authored-By: Claude Opus 4.6 &lt;noreply@anthropic.com&gt;
diff --git a/app/Actions/RefundPluginPurchase.php b/app/Actions/RefundPluginPurchase.php
@@ -0,0 +1,69 @@
+<?php
+
+namespace App\Actions;
+
+use App\Models\PluginLicense;
+use App\Models\User;
+use App\Services\StripeConnectService;
+use Illuminate\Support\Collection;
+use Illuminate\Support\Facades\DB;
+
+class RefundPluginPurchase
+{
+    public function __construct(private StripeConnectService $stripeConnectService) {}
+
+    /**
+     * Refund a plugin purchase, revoking the license and cancelling/reversing the payout.
+     *
+     * For bundle purchases, all sibling licenses sharing the same stripe_payment_intent_id
+     * are refunded together.
+     */
+    public function handle(PluginLicense $license, User $refundedBy): void
+    {
+        if (! $license->isRefundable()) {
+            throw new \RuntimeException('This license is not eligible for a refund.');
+        }
+
+        $licenses = $this->collectLicensesToRefund($license);
+
+        $refund = $this->stripeConnectService->refundPaymentIntent($license->stripe_payment_intent_id);
+
+        DB::transaction(function () use ($licenses, $refund, $refundedBy): void {
+            foreach ($licenses as $licenseToRefund) {
+                $licenseToRefund->update([
+                    'refunded_at' => now(),
+                    'stripe_refund_id' => $refund->id,
+                    'refunded_by' => $refundedBy->id,
+                ]);
+
+                $payout = $licenseToRefund->payout;
+
+                if (! $payout) {
+                    continue;
+                }
+
+                if ($payout->isPending()) {
+                    $payout->markAsCancelled();
+                } elseif ($payout->isTransferred()) {
+                    $this->stripeConnectService->reverseTransfer($payout->stripe_transfer_id);
+                    $payout->markAsCancelled();
+                }
+            }
+        });
+    }
+
+    /**
+     * @return Collection<int, PluginLicense>
+     */
+    private function collectLicensesToRefund(PluginLicense $license): Collection
+    {
+        if (! $license->wasPurchasedAsBundle()) {
+            return collect([$license]);
+        }
+
+        return PluginLicense::query()
+            ->where('stripe_payment_intent_id', $license->stripe_payment_intent_id)
+            ->where('plugin_bundle_id', $license->plugin_bundle_id)
+            ->get();
+    }
+}
diff --git a/app/Enums/PayoutStatus.php b/app/Enums/PayoutStatus.php
@@ -7,13 +7,15 @@ enum PayoutStatus: string
     case Pending = 'pending';
     case Transferred = 'transferred';
     case Failed = 'failed';
+    case Cancelled = 'cancelled';
 
     public function label(): string
     {
         return match ($this) {
             self::Pending => 'Pending',
             self::Transferred => 'Transferred',
             self::Failed => 'Failed',
+            self::Cancelled => 'Cancelled',
         };
     }
 
@@ -23,6 +25,7 @@ public function color(): string
             self::Pending => 'yellow',
             self::Transferred => 'green',
             self::Failed => 'red',
+            self::Cancelled => 'gray',
         };
     }
 }
diff --git a/app/Filament/Resources/PluginResource/RelationManagers/LicensesRelationManager.php b/app/Filament/Resources/PluginResource/RelationManagers/LicensesRelationManager.php
@@ -2,6 +2,10 @@
 
 namespace App\Filament\Resources\PluginResource\RelationManagers;
 
+use App\Actions\RefundPluginPurchase;
+use App\Models\PluginLicense;
+use Filament\Actions;
+use Filament\Notifications\Notification;
 use Filament\Resources\RelationManagers\RelationManager;
 use Filament\Tables;
 use Filament\Tables\Table;
@@ -40,7 +44,48 @@ public function table(Table $table): Table
                     ->dateTime()
                     ->sortable()
                     ->placeholder('Never'),
+
+                Tables\Columns\TextColumn::make('refunded_at')
+                    ->label('Refunded')
+                    ->dateTime()
+                    ->sortable()
+                    ->placeholder('-'),
             ])
-            ->defaultSort('purchased_at', 'desc');
+            ->defaultSort('purchased_at', 'desc')
+            ->actions([
+                Actions\Action::make('refund')
+                    ->label('Refund')
+                    ->color('danger')
+                    ->requiresConfirmation()
+                    ->modalHeading('Refund purchase')
+                    ->modalDescription(function (PluginLicense $record): string {
+                        $amount = '$'.number_format($record->price_paid / 100, 2);
+                        $description = "This will issue a full {$amount} refund to {$record->user->email} and revoke their license.";
+
+                        if ($record->wasPurchasedAsBundle()) {
+                            $description .= ' This license was purchased as part of a bundle — all licenses in the bundle will be refunded.';
+                        }
+
+                        return $description;
+                    })
+                    ->modalSubmitActionLabel('Yes, refund')
+                    ->action(function (PluginLicense $record): void {
+                        try {
+                            app(RefundPluginPurchase::class)->handle($record, auth()->user());
+
+                            Notification::make()
+                                ->title('Purchase refunded successfully')
+                                ->success()
+                                ->send();
+                        } catch (\Exception $e) {
+                            Notification::make()
+                                ->title('Refund failed')
+                                ->body($e->getMessage())
+                                ->danger()
+                                ->send();
+                        }
+                    })
+                    ->visible(fn (PluginLicense $record): bool => $record->isRefundable()),
+            ]);
     }
 }
diff --git a/app/Filament/Resources/UserResource/RelationManagers/PluginLicensesRelationManager.php b/app/Filament/Resources/UserResource/RelationManagers/PluginLicensesRelationManager.php
@@ -2,9 +2,12 @@
 
 namespace App\Filament\Resources\UserResource\RelationManagers;
 
+use App\Actions\RefundPluginPurchase;
 use App\Enums\PluginType;
+use App\Models\PluginLicense;
 use Filament\Actions;
 use Filament\Forms;
+use Filament\Notifications\Notification;
 use Filament\Resources\RelationManagers\RelationManager;
 use Filament\Schemas\Schema;
 use Filament\Tables;
@@ -64,6 +67,11 @@ public function table(Table $table): Table
                     ->dateTime()
                     ->sortable()
                     ->placeholder('Never'),
+                Tables\Columns\TextColumn::make('refunded_at')
+                    ->label('Refunded')
+                    ->dateTime()
+                    ->sortable()
+                    ->placeholder('-'),
             ])
             ->defaultSort('purchased_at', 'desc')
             ->filters([
@@ -80,6 +88,39 @@ public function table(Table $table): Table
                     }),
             ])
             ->actions([
+                Actions\Action::make('refund')
+                    ->label('Refund')
+                    ->color('danger')
+                    ->requiresConfirmation()
+                    ->modalHeading('Refund purchase')
+                    ->modalDescription(function (PluginLicense $record): string {
+                        $amount = '$'.number_format($record->price_paid / 100, 2);
+                        $description = "This will issue a full {$amount} refund to {$record->user->email} for {$record->plugin->name} and revoke their license.";
+
+                        if ($record->wasPurchasedAsBundle()) {
+                            $description .= ' This license was purchased as part of a bundle — all licenses in the bundle will be refunded.';
+                        }
+
+                        return $description;
+                    })
+                    ->modalSubmitActionLabel('Yes, refund')
+                    ->action(function (PluginLicense $record): void {
+                        try {
+                            app(RefundPluginPurchase::class)->handle($record, auth()->user());
+
+                            Notification::make()
+                                ->title('Purchase refunded successfully')
+                                ->success()
+                                ->send();
+                        } catch (\Exception $e) {
+                            Notification::make()
+                                ->title('Refund failed')
+                                ->body($e->getMessage())
+                                ->danger()
+                                ->send();
+                        }
+                    })
+                    ->visible(fn (PluginLicense $record): bool => $record->isRefundable()),
                 Actions\DeleteAction::make(),
             ]);
     }
diff --git a/app/Models/PluginLicense.php b/app/Models/PluginLicense.php
@@ -8,6 +8,7 @@
 use Illuminate\Database\Eloquent\Model;
 use Illuminate\Database\Eloquent\Relations\BelongsTo;
 use Illuminate\Database\Eloquent\Relations\HasOne;
+use Illuminate\Support\Carbon;
 
 class PluginLicense extends Model
 {
@@ -47,6 +48,14 @@ public function pluginBundle(): BelongsTo
         return $this->belongsTo(PluginBundle::class);
     }
 
+    /**
+     * @return BelongsTo<User, PluginLicense>
+     */
+    public function refundedBy(): BelongsTo
+    {
+        return $this->belongsTo(User::class, 'refunded_by');
+    }
+
     public function wasPurchasedAsBundle(): bool
     {
         return $this->plugin_bundle_id !== null;
@@ -59,10 +68,11 @@ public function wasPurchasedAsBundle(): bool
     #[Scope]
     protected function active(Builder $query): Builder
     {
-        return $query->where(function ($q): void {
-            $q->whereNull('expires_at')
-                ->orWhere('expires_at', '>', now());
-        });
+        return $query->whereNull('refunded_at')
+            ->where(function ($q): void {
+                $q->whereNull('expires_at')
+                    ->orWhere('expires_at', '>', now());
+            });
     }
 
     /**
@@ -87,6 +97,10 @@ protected function forPlugin(Builder $query, Plugin $plugin): Builder
 
     public function isActive(): bool
     {
+        if ($this->isRefunded()) {
+            return false;
+        }
+
         if ($this->expires_at === null) {
             return true;
         }
@@ -99,13 +113,40 @@ public function isExpired(): bool
         return ! $this->isActive();
     }
 
+    public function isRefunded(): bool
+    {
+        return $this->refunded_at !== null;
+    }
+
+    public function isRefundable(): bool
+    {
+        if ($this->isRefunded()) {
+            return false;
+        }
+
+        if ($this->is_grandfathered) {
+            return false;
+        }
+
+        if ($this->price_paid <= 0) {
+            return false;
+        }
+
+        if (! $this->stripe_payment_intent_id) {
+            return false;
+        }
+
+        return $this->purchased_at->diffInDays(Carbon::now()) <= 14;
+    }
+
     protected function casts(): array
     {
         return [
             'price_paid' => 'integer',
             'is_grandfathered' => 'boolean',
             'purchased_at' => 'datetime',
             'expires_at' => 'datetime',
+            'refunded_at' => 'datetime',
         ];
     }
 }
diff --git a/app/Models/PluginPayout.php b/app/Models/PluginPayout.php
@@ -63,6 +63,16 @@ protected function failed(Builder $query): Builder
         return $query->where('status', PayoutStatus::Failed);
     }
 
+    /**
+     * @param  Builder<PluginPayout>  $query
+     * @return Builder<PluginPayout>
+     */
+    #[Scope]
+    protected function cancelled(Builder $query): Builder
+    {
+        return $query->where('status', PayoutStatus::Cancelled);
+    }
+
     /**
      * @return array{platform_fee: int, developer_amount: int}
      */
@@ -108,6 +118,18 @@ public function markAsFailed(): void
         ]);
     }
 
+    public function markAsCancelled(): void
+    {
+        $this->update([
+            'status' => PayoutStatus::Cancelled,
+        ]);
+    }
+
+    public function isCancelled(): bool
+    {
+        return $this->status === PayoutStatus::Cancelled;
+    }
+
     protected function casts(): array
     {
         return [
diff --git a/app/Services/StripeConnectService.php b/app/Services/StripeConnectService.php
@@ -13,6 +13,8 @@
 use Illuminate\Support\Facades\Log;
 use Laravel\Cashier\Cashier;
 use Stripe\Account;
+use Stripe\Refund;
+use Stripe\TransferReversal;
 
 /**
  * Service for managing Stripe Connect accounts and processing developer payouts.
@@ -186,6 +188,19 @@ protected function determineStatus(Account $account): StripeConnectStatus
         return StripeConnectStatus::Pending;
     }
 
+    public function refundPaymentIntent(string $paymentIntentId): Refund
+    {
+        return Cashier::stripe()->refunds->create([
+            'payment_intent' => $paymentIntentId,
+        ]);
+    }
+
+    public function reverseTransfer(string $stripeTransferId): TransferReversal
+    {
+        return Cashier::stripe()->transfers->retrieve($stripeTransferId)
+            ->reversals->create();
+    }
+
     public function createProductAndPrice(Plugin $plugin, int $amountCents, string $currency = 'usd'): PluginPrice
     {
         $product = Cashier::stripe()->products->create([
diff --git a/database/factories/PluginLicenseFactory.php b/database/factories/PluginLicenseFactory.php
@@ -51,4 +51,13 @@ public function grandfathered(): static
             'is_grandfathered' => true,
         ]);
     }
+
+    public function refunded(): static
+    {
+        return $this->state(fn (array $attributes) => [
+            'refunded_at' => now(),
+            'stripe_refund_id' => 're_'.$this->faker->uuid(),
+            'refunded_by' => User::factory(),
+        ]);
+    }
 }
diff --git a/database/factories/PluginPayoutFactory.php b/database/factories/PluginPayoutFactory.php
diff --git a/database/migrations/2026_04_08_180245_add_refund_fields_to_plugin_licenses_and_update_sales_view.php b/database/migrations/2026_04_08_180245_add_refund_fields_to_plugin_licenses_and_update_sales_view.php
diff --git a/package-lock.json b/package-lock.json
diff --git a/tests/Feature/PluginPurchaseRefundTest.php b/tests/Feature/PluginPurchaseRefundTest.php

Original file line number	Diff line number	Diff line change
`@@ -7,13 +7,15 @@ enum PayoutStatus: string`
`7`	`7`	`case Pending = 'pending';`
`8`	`8`	`case Transferred = 'transferred';`
`9`	`9`	`case Failed = 'failed';`
	`10`	`+ case Cancelled = 'cancelled';`
`10`	`11`
`11`	`12`	`public function label(): string`
`12`	`13`	`{`
`13`	`14`	`return match ($this) {`
`14`	`15`	`self::Pending => 'Pending',`
`15`	`16`	`self::Transferred => 'Transferred',`
`16`	`17`	`self::Failed => 'Failed',`
	`18`	`+ self::Cancelled => 'Cancelled',`
`17`	`19`	`};`
`18`	`20`	`}`
`19`	`21`
`@@ -23,6 +25,7 @@ public function color(): string`
`23`	`25`	`self::Pending => 'yellow',`
`24`	`26`	`self::Transferred => 'green',`
`25`	`27`	`self::Failed => 'red',`
	`28`	`+ self::Cancelled => 'gray',`
`26`	`29`	`};`
`27`	`30`	`}`
`28`	`31`	`}`
Original file line number	Diff line number	Diff line change
`@@ -51,4 +51,13 @@ public function grandfathered(): static`
`51`	`51`	`'is_grandfathered' => true,`
`52`	`52`	`]);`
`53`	`53`	`}`
	`54`	`+`
	`55`	`+ public function refunded(): static`
	`56`	`+ {`
	`57`	`+ return $this->state(fn (array $attributes) => [`
	`58`	`+ 'refunded_at' => now(),`
	`59`	`+ 'stripe_refund_id' => 're_'.$this->faker->uuid(),`
	`60`	`+ 'refunded_by' => User::factory(),`
	`61`	`+ ]);`
	`62`	`+ }`
`54`	`63`	`}`