Extiende la autenticación de Laravel: crea guards personalizados

#Entender los guards

Los guards personalizados le permiten definir su propia lógica de autenticación, lo que puede ser particularmente útil para implementar la autenticación JWT, OAuth o cualquier otro sistema de autenticación especializado que no se ajuste a los tipos de protectores predeterminados de Laravel.

#Crear un guard personalizado

Para crear un guard personalizado, deberá utilizar el método Auth::extend(). Esto se hace normalmente en un service provider. Repasemos el proceso:

1. Cree su clase guard

Primero, cree una nueva clase que implemente la interfaz IlluminateContractsAuthGuard. Para este ejemplo, crearemos un guard JWT simple:

namespace AppServicesAuth;

use IlluminateContractsAuthGuard;

class JwtGuard implements Guard
{
    protected $provider;
    protected $user;

    public function __construct($provider)
    {
        $this->provider = $provider;
    }

    public function check()
    {
        // Check if the user is authenticated
    }

    public function user()
    {
        // Return the authenticated user
    }

    // Implement other methods required by the Guard interface
}

2. Registra el guard personalizado

En tu AppServiceProvider o en un AuthServiceProvider dedicado, registra tu guard personalizado:

namespace AppProviders;

use AppServicesAuthJwtGuard;
use IlluminateSupportFacadesAuth;
use IlluminateSupportServiceProvider;

class AppServiceProvider extends ServiceProvider
{
    public function boot()
    {
        Auth::extend('jwt', function ($app, $name, array $config) {
            return new JwtGuard(Auth::createUserProvider($config['provider']));
        });
    }
}

3. Configura el guard

En tu fichero config/auth.php, añade tu nuevo guard:

'guards' => [
    'web' => [
        'driver' => 'session',
        'provider' => 'users',
    ],
    'api' => [
        'driver' => 'jwt',
        'provider' => 'users',
    ],
],

#Implementando la lógica del guard

En la clase guard, deberás implementar la lógica de autenticación. A continuación, se muestra un ejemplo básico de cómo podrían verse los métodos check() y user() en un guard JWT:

public function check()
{
    if (! $this->user) {
        $token = $this->getTokenFromRequest();
        
        if ($token && $this->validateToken($token)) {
            $this->user = $this->provider->retrieveById($this->getPayload($token)->sub);
        }
    }

    return $this->user !== null;
}

public function user()
{
    if (! $this->user) {
        $this->check();
    }

    return $this->user;
}

protected function getTokenFromRequest()
{
    // Logic to extract JWT from request
}

protected function validateToken($token)
{
    // Logic to validate JWT
}

protected function getPayload($token)
{
    // Logic to decode and return JWT payload
}

#Usando tu guard personalizado

Una vez que tu guard esté configurado, puedes usarla como cualquier otro guard de Laravel:

if (Auth::guard('api')->check()) {
    $user = Auth::guard('api')->user();
    // Do something with the authenticated user
}

También puede configurarlo como guard predeterminada para ciertas rutas en tu RouteServiceProvider:

protected function mapApiRoutes()
{
    Route::prefix('api')
         ->middleware('auth:api')
         ->namespace($this->namespace)
         ->group(base_path('routes/api.php'));
}

Al crear guard de autenticación personalizados, puede adaptar el sistema de autenticación de Laravel para satisfacer sus necesidades específicas. Ya sea que esté implementando JWT, OAuth o cualquier otro método de autenticación, los guard personalizados brindan la flexibilidad para integrarse sin problemas con las funciones de autenticación existentes de Laravel.