Autenticación OAuth 2.0 - Google Sheets API for Laravel

Con la autenticación OAuth 2.0, cada usuario concede permiso de acceso a sus propias Google Sheets. Es la opción adecuada para aplicaciones que manejan datos por usuario.

Casos de uso

Aplicaciones centradas en el usuario: cada usuario accede a sus propias Google Sheets.
Aplicaciones multi-tenant: usuarios distintos gestionan hojas de cálculo distintas.
Acceso a datos personales: lectura y escritura de hojas de cuentas propias del usuario.
Aplicaciones de escritorio y web: donde hay interacción con el usuario.

Requisitos previos

Un proyecto en Google Cloud Console
Google Sheets API y Google Drive API habilitadas
Laravel Socialite (recomendado)

Configuración

Configura Google Cloud Console

Accede a Google Cloud Console.
Selecciona un proyecto o crea uno nuevo.
Ve a APIs & Services > Library.
Habilita las siguientes APIs:
- Google Sheets API
- Google Drive API

Crea las credenciales OAuth 2.0

Ve a APIs & Services > Credentials.
Haz clic en Create Credentials > OAuth client ID.
Configura la pantalla de consentimiento OAuth (solo la primera vez):
- Selecciona el tipo de usuario External.
- Rellena los campos obligatorios (nombre de la aplicación, correo de soporte, contacto del desarrollador).
- Añade los scopes: https://www.googleapis.com/auth/spreadsheets y https://www.googleapis.com/auth/drive.
Selecciona el tipo de aplicación Web application.
Añade las URIs de redirección autorizadas:
- Desarrollo: http://localhost:8000/auth/google/callback
- Producción: https://yourdomain.com/auth/google/callback
Haz clic en Create.
Copia el Client ID y el Client Secret.

Configura el entorno Laravel

Añade al archivo .env:

GOOGLE_CLIENT_ID=your-client-id-here
GOOGLE_CLIENT_SECRET=your-client-secret-here
GOOGLE_REDIRECT=http://localhost:8000/auth/google/callback

Actualiza config/google.php:

'client_id' => env('GOOGLE_CLIENT_ID', ''),
'client_secret' => env('GOOGLE_CLIENT_SECRET', ''),
'redirect_uri' => env('GOOGLE_REDIRECT', ''),
'scopes' => [
    \Google\Service\Sheets::SPREADSHEETS,
    \Google\Service\Drive::DRIVE,
],
'access_type' => 'offline', // imprescindible para el refresh token
'prompt' => 'consent select_account',

Instala Laravel Socialite

composer require laravel/socialite

Añade en config/services.php:

'google' => [
    'client_id' => env('GOOGLE_CLIENT_ID'),
    'client_secret' => env('GOOGLE_CLIENT_SECRET'),
    'redirect' => env('GOOGLE_REDIRECT'),
],

Implementa el controlador de autenticación

// app/Http/Controllers/AuthController.php
<?php

namespace App\Http\Controllers;

use App\Models\User;
use Illuminate\Http\Request;
use Laravel\Socialite\Facades\Socialite;

class AuthController extends Controller
{
    public function redirectToGoogle()
    {
        return Socialite::driver('google')
            ->scopes(config('google.scopes'))
            ->with([
                'access_type' => config('google.access_type'),
                'prompt' => config('google.prompt'),
            ])
            ->redirect();
    }

    public function handleGoogleCallback()
    {
        try {
            $googleUser = Socialite::driver('google')->user();
            
            $user = User::updateOrCreate(
                ['email' => $googleUser->email],
                [
                    'name' => $googleUser->name,
                    'email' => $googleUser->email,
                    'google_access_token' => $googleUser->token,
                    'google_refresh_token' => $googleUser->refreshToken,
                    'google_expires_in' => $googleUser->expiresIn,
                    'google_token_created' => now()->timestamp,
                ]
            );

            auth()->login($user);

            return redirect('/dashboard')->with('success', 'Autenticación con Google correcta');
        } catch (\Exception $e) {
            return redirect('/login')
                ->with('error', 'Fallo de autenticación: ' . $e->getMessage());
        }
    }

    public function logout(Request $request)
    {
        auth()->logout();
        $request->session()->invalidate();
        $request->session()->regenerateToken();

        return redirect('/');
    }
}

Añade las rutas

// routes/web.php
Route::get('/auth/google', [AuthController::class, 'redirectToGoogle'])
    ->name('google.redirect');
Route::get('/auth/google/callback', [AuthController::class, 'handleGoogleCallback'])
    ->name('google.callback');
Route::post('/logout', [AuthController::class, 'logout'])
    ->name('logout');

Actualiza el modelo User

Migración:

// database/migrations/add_google_tokens_to_users_table.php
Schema::table('users', function (Blueprint $table) {
    $table->text('google_access_token')->nullable();
    $table->text('google_refresh_token')->nullable();
    $table->integer('google_expires_in')->nullable();
    $table->integer('google_token_created')->nullable();
});

Modelo User:

// app/Models/User.php
protected $fillable = [
    'name',
    'email',
    'password',
    'google_access_token',
    'google_refresh_token',
    'google_expires_in',
    'google_token_created',
];

protected $hidden = [
    'password',
    'remember_token',
    'google_access_token',
    'google_refresh_token',
];

public function getGoogleTokenArray(): array
{
    return [
        'access_token' => $this->google_access_token,
        'refresh_token' => $this->google_refresh_token,
        'expires_in' => $this->google_expires_in,
        'created' => $this->google_token_created,
    ];
}

public function hasValidGoogleToken(): bool
{
    return !empty($this->google_access_token) 
        && !empty($this->google_refresh_token);
}

Usa Sheets

use Revolution\Google\Sheets\Facades\Sheets;

public function getSheetData(Request $request)
{
    $user = $request->user();
    
    if (!$user->hasValidGoogleToken()) {
        return redirect()->route('google.redirect');
    }

    try {
        $token = $user->getGoogleTokenArray();

        $values = Sheets::setAccessToken($token)
            ->spreadsheet('user-spreadsheet-id')
            ->sheet('Sheet1')
            ->all();
            
        return view('sheets.data', compact('values'));
    } catch (\Exception $e) {
        // Si el token ha caducado, reautenticar
        if (str_contains($e->getMessage(), 'invalid_grant') 
            || str_contains($e->getMessage(), 'unauthorized')) {
            return redirect()->route('google.redirect');
        }

        throw $e;
    }
}

Refresco de tokens

El paquete gestiona automáticamente la caducidad de los tokens:

$token = [
    'access_token' => $user->google_access_token,
    'refresh_token' => $user->google_refresh_token,
    'expires_in' => $user->google_expires_in,
    'created' => $user->google_token_created,
];

// Si ha caducado, se refresca automáticamente
Sheets::setAccessToken($token)
    ->spreadsheet('id')
    ->sheet('Sheet1')
    ->all();

// Obtén el token actualizado tras el refresco
$updatedToken = Sheets::getAccessToken();
if ($updatedToken) {
    $user->update([
        'google_access_token' => $updatedToken['access_token'],
        'google_token_created' => time(),
    ]);
}

Middleware

Middleware que exige autenticación con Google:

// app/Http/Middleware/RequireGoogleAuth.php
<?php

namespace App\Http\Middleware;

use Closure;
use Illuminate\Http\Request;

class RequireGoogleAuth
{
    public function handle(Request $request, Closure $next)
    {
        $user = $request->user();

        if (!$user || !$user->hasValidGoogleToken()) {
            if ($request->expectsJson()) {
                return response()->json(
                    ['error' => 'Se requiere autenticación con Google'], 
                    401
                );
            }

            return redirect()->route('google.redirect');
        }

        return $next($request);
    }
}

Seguridad

1. Almacenamiento de tokens

Guarda los tokens de forma segura en la base de datos.
Usa el cifrado integrado de Laravel.
No expongas los tokens al lado cliente.

2. Gestión de scopes

Solicita únicamente los scopes mínimos necesarios.
Aplica el principio de mínimos privilegios.
Explica claramente al usuario los permisos que necesitas.

3. Manejo de errores

Gestiona correctamente los tokens caducados.
Ofrece un flujo de reautenticación amigable para el usuario.
Registra y monitoriza los errores.

Resolución de problemas

Errores frecuentes

Error “redirect_uri_mismatch”

Comprueba que la URI de redirección de Google Console coincide exactamente con la de la aplicación.
Verifica diferencias entre http y https.
Comprueba la barra final.

Errores “invalid_grant” o “unauthorized”

El token ha caducado y el refresco ha fallado.
Pide al usuario que se autentique de nuevo.
Comprueba que existe el refresh token.

Error “access_denied”

El usuario ha denegado el permiso.
Muestra un mensaje adecuado.
Ofrece la opción de volver a intentar la autenticación.

Ruta de test

Route::get('/test-oauth', function (Request $request) {
    $user = $request->user();
    
    if (!$user->hasValidGoogleToken()) {
        return 'No hay token de Google. '
            . '<a href="' . route('google.redirect') . '">'
            . 'Autenticar</a>';
    }
    
    try {
        $token = $user->getGoogleTokenArray();
        $sheets = Sheets::setAccessToken($token)->spreadsheetList();
        
        return '¡OAuth funcionando! Número de hojas de cálculo: ' 
            . count($sheets);
    } catch (\Exception $e) {
        return 'Error de OAuth: ' . $e->getMessage();
    }
})->middleware('auth');

​Casos de uso

​Requisitos previos

​Configuración

​Refresco de tokens

​Middleware

​Seguridad

​1. Almacenamiento de tokens

​2. Gestión de scopes

​3. Manejo de errores

​Resolución de problemas

​Errores frecuentes

​Ruta de test