Autenticación OAuth 2.0 - Google Sheets API for Laravel

Autenticación OAuth 2.0 para la API de Google Sheets. Para acceso por usuario.

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

1. Configura Google Cloud Console

   1. Accede a Google Cloud Console.
   2. Selecciona un proyecto o crea uno nuevo.
   3. Ve a APIs & Services > Library.
   4. Habilita las siguientes APIs:
      • Google Sheets API
      • Google Drive API
2. Crea las credenciales OAuth 2.0

   1. Ve a APIs & Services > Credentials.
   2. Haz clic en Create Credentials > OAuth client ID.
   3. 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.
   4. Selecciona el tipo de aplicación Web application.
   5. Añade las URIs de redirección autorizadas:
      • Desarrollo: http://localhost:8000/auth/google/callback
      • Producción: https://yourdomain.com/auth/google/callback
   6. Haz clic en Create.
   7. Copia el Client ID y el Client Secret.
3. 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',
   
4. 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'),
   ],
   
5. 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('/');
       }
   }
   
6. 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');
   
7. 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);
   }
   
8. 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');