Request Handling with PHP Enums in Laravel

Explanation:

Code:

use App\Enums\UserRole;
// Basic enum retrieval
$role = $request->enum('role', UserRole::class);

Here's an example of building a subscription management system:

// app/Enums/SubscriptionTier.php
<?php
 
namespace App\Enums;
 
enum SubscriptionTier: string
{
    case FREE = 'free';
    case BASIC = 'basic';
    case PRO = 'pro';
    case ENTERPRISE = 'enterprise';
 
    public function getMonthlyLimit(): int
    {
        return match($this) {
            self::FREE => 1000,
            self::BASIC => 5000,
            self::PRO => 20000,
            self::ENTERPRISE => 100000
        };
    }
}
 
// app/Controllers/AccountController.php
namespace App\Http\Controllers;
 
use App\Enums\SubscriptionTier;
use App\Models\Account;
use Illuminate\Http\Request;
 
class AccountController extends Controller
{
    public function updateSubscription(Request $request, Account $account)
    {
        $newTier = $request->enum('tier', SubscriptionTier::class);
        if (!$newTier) {
            return response()->json([
                'error' => 'Invalid subscription tier provided'
            ], 422);
        }
        $account->update([
            'subscription_tier' => $newTier,
            'monthly_limit' => $newTier->getMonthlyLimit(),
            'upgraded_at' => now()
        ]);
 
        return response()->json([
            'message' => 'Subscription updated successfully',
            'account' => $account->fresh()
        ]);
    }
}

Example usage:

// Input request
{
    "tier": "pro"
}
 
// Success response
{
    "message": "Subscription updated successfully",
    "account": {
        "id": 1,
        "subscription_tier": "pro",
        "monthly_limit": 20000,
        "upgraded_at": "2024-02-01T10:30:00.000000Z"
    }
}
 
// Invalid input
{
    "tier": "premium"  // Non-existent enum value
}
 
// Error response
{
    "error": "Invalid subscription tier provided"
}

Request enum handling provides a robust way to process enumerated values while maintaining type safety and domain integrity.