jwt_auth_cognito 0.1.0

data/README.md

@@ -0,0 +1,384 @@
+# JWT Auth Cognito
+
+Una gema Ruby para validar tokens JWT de AWS Cognito de forma offline con funcionalidad de blacklist basada en Redis.
+
+## Características
+
+- **Validación JWT Offline**: Valida tokens JWT de Cognito sin llamar a las APIs de AWS
+- **Soporte JWKS**: Recuperación automática y cache de claves públicas desde el endpoint JWKS de Cognito
+- **Blacklist de Tokens**: Gestión de revocación y blacklist de tokens basada en Redis con soporte TLS completo
+- **Configuración Flexible**: Soporte para modos de validación seguro (producción) y básico (desarrollo)
+- **Gestión de Tokens de Usuario**: Rastrear e invalidar todos los tokens de un usuario específico
+- **Múltiples Tipos de Token**: Soporte para access tokens e ID tokens
+- **Manejo Integral de Errores**: Degradación elegante cuando Redis no está disponible
+- **Soporte TLS Avanzado**: Configuración completa de TLS para Redis con certificados CA
+
+## Instalación
+
+Agrega esta línea al Gemfile de tu aplicación:
+
+```ruby
+gem 'jwt_auth_cognito'
+```
+
+Y luego ejecuta:
+
+    $ bundle install
+
+O instálala directamente:
+
+    $ gem install jwt_auth_cognito
+
+## Configuración
+
+Configura la gema en un inicializador (ej. `config/initializers/jwt_auth_cognito.rb`):
+
+```ruby
+JwtAuthCognito.configure do |config|
+  # Requerido: Configuración de AWS Cognito
+  config.cognito_user_pool_id = 'us-east-1_abcdef123'
+  config.cognito_region = 'us-east-1'
+  config.cognito_client_id = 'tu-client-id' # Opcional, para validación de audiencia
+  config.cognito_client_secret = 'tu-client-secret' # Opcional, para mayor seguridad
+  
+  # Requerido: Configuración de Redis para blacklisting
+  config.redis_host = 'localhost'
+  config.redis_port = 6379
+  config.redis_password = 'tu-password-redis' # Opcional
+  config.redis_db = 0
+  
+  # Configuración TLS para Redis (Producción)
+  config.redis_ssl = true
+  config.redis_ca_cert_path = '/ruta/a/certificados'
+  config.redis_ca_cert_name = 'redis-ca.crt'
+  config.redis_tls_min_version = 'TLSv1.2'
+  config.redis_tls_max_version = 'TLSv1.3'
+  config.redis_verify_mode = 'peer'
+  
+  # Opcional: Configuraciones de cache y validación
+  config.jwks_cache_ttl = 3600 # 1 hora
+  config.validation_mode = :secure # :secure o :basic
+end
+```
+
+### Variables de Entorno
+
+La gema soporta configuración mediante variables de entorno:
+
+```bash
+# Configuración de Cognito
+COGNITO_USER_POOL_ID=us-east-1_abcdef123
+COGNITO_REGION=us-east-1
+COGNITO_CLIENT_ID=tu-client-id
+COGNITO_CLIENT_SECRET=tu-client-secret
+
+# Configuración de Redis
+REDIS_HOST=localhost
+REDIS_PORT=6379
+REDIS_PASSWORD=tu-password
+REDIS_DB=0
+REDIS_TLS=true
+
+# Configuración TLS de Redis
+REDIS_CA_CERT_PATH=/ruta/a/certificados
+REDIS_CA_CERT_NAME=redis-ca.crt
+REDIS_TLS_MIN_VERSION=TLSv1.2
+REDIS_TLS_MAX_VERSION=TLSv1.3
+REDIS_VERIFY_MODE=peer
+
+# Configuración de cache
+JWKS_CACHE_TTL=3600
+```
+
+## Uso
+
+### Validación Básica de Tokens
+
+```ruby
+validator = JwtAuthCognito::JwtValidator.new
+
+# Validar cualquier token JWT
+result = validator.validate_token(jwt_token)
+
+if result[:valid]
+  puts "¡Token válido!"
+  puts "ID de Usuario: #{result[:sub]}"
+  puts "Nombre de Usuario: #{result[:username]}"
+  puts "Tipo de Token: #{result[:token_use]}"
+else
+  puts "Token inválido: #{result[:error]}"
+end
+```
+
+### Validar Tipos Específicos de Token
+
+```ruby
+# Validar específicamente access token
+result = validator.validate_access_token(jwt_token)
+
+# Validar específicamente ID token  
+result = validator.validate_id_token(jwt_token)
+```
+
+### Opciones Avanzadas de Validación
+
+```ruby
+# Validar con requisitos personalizados
+result = validator.validate_token(jwt_token, {
+  user_id: 'id-usuario-esperado',
+  client_id: 'client-id-esperado',
+  token_use: 'access',
+  required_scopes: ['read', 'write']
+})
+```
+
+### Blacklist de Tokens
+
+```ruby
+# Revocar un token específico
+validator.revoke_token(jwt_token, user_id: 'usuario-123')
+
+# Revocar todos los tokens de un usuario
+validator.revoke_user_tokens('usuario-123')
+
+# Verificar si un token está en blacklist
+blacklisted = validator.validate_token(jwt_token)
+# Retornará { valid: false, error: "Token has been revoked" }
+```
+
+### Validación en Lote
+
+```ruby
+tokens = [token1, token2, token3]
+results = validator.validate_multiple_tokens(tokens)
+
+results.each_with_index do |result, index|
+  puts "Token #{index + 1}: #{result[:valid] ? 'Válido' : result[:error]}"
+end
+```
+
+### Métodos Utilitarios
+
+```ruby
+# Extraer token del header Authorization
+token = validator.extract_token_from_header(request.headers['Authorization'])
+
+# Obtener información del token
+info = validator.get_token_info(token)
+puts "Usuario: #{info[:username]}"
+puts "Expira en: #{info[:expires_at]}"
+puts "Tiene client secret: #{info[:has_client_secret]}"
+
+# Verificar expiración
+expired = validator.is_token_expired?(token)
+
+# Obtener tiempo hasta expiración
+seconds_to_expiry = validator.get_time_to_expiry(token)
+
+# Calcular secret hash (para operaciones de Cognito)
+# Útil si necesitas hacer operaciones directas con Cognito SDK
+secret_hash = validator.calculate_secret_hash('username_or_email')
+```
+
+### Uso Directo de Servicios
+
+```ruby
+# Usar servicios directamente para mayor control
+blacklist_service = JwtAuthCognito::TokenBlacklistService.new
+jwks_service = JwtAuthCognito::JwksService.new
+
+# Agregar token a blacklist con TTL personalizado
+blacklist_service.add_to_blacklist(token, user_id: 'usuario-123')
+
+# Validar con JWKS
+result = jwks_service.validate_token_with_jwks(token)
+```
+
+## Modos de Validación
+
+### Modo Seguro (Producción)
+- Validación completa de firma JWKS
+- Recuperación automática y cache de claves públicas
+- Validación completa de claims
+- Recomendado para entornos de producción
+
+### Modo Básico (Desarrollo)
+- Solo validación de estructura del token
+- Sin verificación de firma
+- Validación más rápida para desarrollo/testing
+- **NO recomendado para producción**
+
+```ruby
+# Configurar modo de validación
+JwtAuthCognito.configure do |config|
+  config.validation_mode = :basic # Para desarrollo
+  config.validation_mode = :secure # Para producción
+end
+```
+
+## Manejo de Errores
+
+La gema proporciona tipos de error específicos:
+
+- `JwtAuthCognito::ValidationError`: Fallas de validación de tokens
+- `JwtAuthCognito::TokenExpiredError`: Token expirado
+- `JwtAuthCognito::TokenRevokedError`: Token revocado
+- `JwtAuthCognito::BlacklistError`: Fallas en operaciones de Redis/blacklist  
+- `JwtAuthCognito::ConfigurationError`: Problemas de configuración
+- `JwtAuthCognito::JWKSError`: Errores de JWKS
+- `JwtAuthCognito::RedisConnectionError`: Problemas de conexión a Redis
+
+```ruby
+begin
+  result = validator.validate_token(token)
+rescue JwtAuthCognito::TokenExpiredError => e
+  puts "Token expirado: #{e.message}"
+rescue JwtAuthCognito::BlacklistError => e
+  puts "Error de blacklist: #{e.message}"
+end
+```
+
+## Integración con Rails
+
+### Ejemplo de Middleware
+
+```ruby
+class JwtAuthenticationMiddleware
+  def initialize(app)
+    @app = app
+    @validator = JwtAuthCognito::JwtValidator.new
+  end
+
+  def call(env)
+    request = Rack::Request.new(env)
+    token = @validator.extract_token_from_header(request.get_header('HTTP_AUTHORIZATION'))
+    
+    if token
+      result = @validator.validate_access_token(token)
+      if result[:valid]
+        env['current_user_id'] = result[:sub]
+        env['current_username'] = result[:username]
+      else
+        return unauthorized_response(result[:error])
+      end
+    end
+    
+    @app.call(env)
+  end
+
+  private
+
+  def unauthorized_response(error)
+    [401, { 'Content-Type' => 'application/json' }, 
+     [{ error: 'No Autorizado', message: error }.to_json]]
+  end
+end
+```
+
+### Helper para Controladores
+
+```ruby
+module JwtAuthHelper
+  extend ActiveSupport::Concern
+
+  included do
+    before_action :authenticate_jwt_token!
+  end
+
+  private
+
+  def authenticate_jwt_token!
+    token = jwt_validator.extract_token_from_header(request.headers['Authorization'])
+    return render_unauthorized('Token faltante') unless token
+
+    result = jwt_validator.validate_access_token(token)
+    
+    if result[:valid]
+      @current_user_id = result[:sub]
+      @current_username = result[:username]
+    else
+      render_unauthorized(result[:error])
+    end
+  end
+
+  def jwt_validator
+    @jwt_validator ||= JwtAuthCognito::JwtValidator.new
+  end
+
+  def render_unauthorized(message)
+    render json: { error: 'No Autorizado', message: message }, status: :unauthorized
+  end
+end
+```
+
+### Integración con Llegando-Neo
+
+```ruby
+# En config/initializers/jwt_auth_cognito.rb
+JwtAuthCognito.configure do |config|
+  # Reutilizar configuración existente de Redis
+  redis_config = Rails.application.config_for(:redis)
+  config.redis_host = redis_config[:host]
+  config.redis_port = redis_config[:port]
+  config.redis_password = redis_config[:password]
+  config.redis_ssl = redis_config[:ssl]
+  
+  # Configuración de Cognito desde secrets
+  config.cognito_user_pool_id = Rails.application.secrets.cognito_user_pool_id
+  config.cognito_region = Rails.application.secrets.cognito_region
+  config.cognito_client_id = Rails.application.secrets.cognito_client_id
+  
+  config.validation_mode = Rails.env.production? ? :secure : :basic
+end
+```
+
+## Compatibilidad
+
+- **Ruby**: >= 2.7.0 (Compatible con llegando-neo Ruby 2.7.5)
+- **Rails**: >= 5.0 (Compatible con llegando-neo Rails 5.2.6)
+- **Redis**: >= 4.2.5 (Compatible con llegando-neo redis >= 4.2.5)
+
+## Desarrollo
+
+Después de clonar el repositorio, ejecuta `bin/setup` para instalar dependencias. Luego, ejecuta `rake spec` para correr las pruebas. También puedes ejecutar `bin/console` para una consola interactiva que te permitirá experimentar.
+
+Para instalar esta gema localmente, ejecuta `bundle exec rake install`. Para liberar una nueva versión, actualiza el número de versión en `version.rb`, y luego ejecuta `bundle exec rake release`.
+
+## Contribución
+
+Los reportes de bugs y pull requests son bienvenidos en GitHub.
+
+## Licencia
+
+La gema está disponible como código abierto bajo los términos de la [Licencia MIT](https://opensource.org/licenses/MIT).
+
+## Generación Automática de Configuración
+
+### Usando el generador de Rails
+
+```bash
+# Generar configuración automáticamente
+rails generate jwt_auth_cognito:install
+```
+
+### Usando tareas Rake
+
+```bash
+# Instalar configuración
+rake jwt_auth_cognito:install
+
+# Ver configuración actual
+rake jwt_auth_cognito:config
+
+# Probar conexiones
+rake jwt_auth_cognito:test_cognito
+rake jwt_auth_cognito:test_redis
+
+# Limpiar blacklist
+rake jwt_auth_cognito:clear_blacklist
+```
+
+Esto generará automáticamente:
+- `config/initializers/jwt_auth_cognito.rb` - Archivo de configuración
+- `.env.example` - Variables de entorno de ejemplo
+- Configuración optimizada para tu proyecto Rails

data/Rakefile

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+require "rubocop/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+RuboCop::RakeTask.new
+
+desc "Run tests"
+task default: %i[spec rubocop]

data/jwt_auth_cognito.gemspec

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+require_relative "lib/jwt_auth_cognito/version"
+
+Gem::Specification.new do |spec|
+  spec.name = "jwt_auth_cognito"
+  spec.version = JwtAuthCognito::VERSION
+  spec.authors = ["The Optimal"]
+  spec.email = ["contact@theoptimal.com"]
+
+  spec.summary = "Validación offline de JWT con AWS Cognito y blacklist Redis"
+  spec.description = "Gema Ruby para validar tokens JWT de AWS Cognito de forma offline con funcionalidad de blacklist basada en Redis y soporte TLS completo"
+  spec.homepage = "https://github.com/theoptimal/jwt-auth-cognito"
+  spec.license = "MIT"
+  spec.required_ruby_version = ">= 2.7.0"
+
+  spec.metadata["allowed_push_host"] = "https://rubygems.org"
+  spec.metadata["homepage_uri"] = spec.homepage
+  spec.metadata["source_code_uri"] = spec.homepage
+  spec.metadata["changelog_uri"] = "#{spec.homepage}/blob/main/CHANGELOG.md"
+  spec.metadata["documentation_uri"] = "#{spec.homepage}/blob/main/README.md"
+  spec.metadata["bug_tracker_uri"] = "#{spec.homepage}/issues"
+
+  # Specify which files should be added to the gem when it is released.
+  spec.files = Dir.chdir(__dir__) do
+    files = Dir.glob("lib/**/*.{rb,rake,erb}") + 
+            Dir.glob("*.{md,txt,yml}") + 
+            ["Gemfile", "Rakefile", "jwt_auth_cognito.gemspec"]
+    
+    # Add optional files if they exist
+    files << ".rspec" if File.exist?(".rspec")
+    files << ".rubocop.yml" if File.exist?(".rubocop.yml")
+    
+    files
+  end
+  spec.bindir = "exe"
+  spec.executables = spec.files.grep(%r{\Aexe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  # Dependencies - compatible with llegando-neo (Ruby 2.7.5, Rails 5.2.6)
+  spec.add_dependency "jwt", "~> 2.0"
+  spec.add_dependency "redis", ">= 4.2.5", "< 6.0" # Compatible with llegando-neo redis version
+  spec.add_dependency "openssl", ">= 2.1.0" # For TLS support
+  spec.add_dependency "json", "~> 2.0"
+
+  # Development dependencies
+  spec.add_development_dependency "rspec", "~> 3.0"
+  spec.add_development_dependency "bundler", ">= 1.17", "< 3.0"
+  spec.add_development_dependency "rake", "~> 13.0"
+  spec.add_development_dependency "rubocop", "~> 1.0"
+  spec.add_development_dependency "webmock", "~> 3.0"
+end

data/lib/generators/jwt_auth_cognito/install_generator.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+require 'rails/generators'
+
+module JwtAuthCognito
+  module Generators
+    class InstallGenerator < Rails::Generators::Base
+      desc "Genera el archivo de configuración inicial para jwt_auth_cognito"
+      
+      source_root File.expand_path('templates', __dir__)
+      
+      def create_initializer
+        say "Creando archivo de configuración jwt_auth_cognito..."
+        template 'jwt_auth_cognito.rb.erb', 'config/initializers/jwt_auth_cognito.rb'
+        say "✓ Archivo de configuración creado en config/initializers/jwt_auth_cognito.rb", :green
+      end
+
+      def create_env_example
+        if File.exist?('.env.example')
+          append_to_file '.env.example', env_variables
+          say "✓ Variables de entorno agregadas a .env.example", :green
+        else
+          create_file '.env.example', env_variables
+          say "✓ Archivo .env.example creado con variables de entorno", :green
+        end
+      end
+
+      def show_next_steps
+        say "\n" + "="*60, :blue
+        say "🎉 ¡Configuración de jwt_auth_cognito completada!", :green
+        say "="*60, :blue
+        say "\n📋 PRÓXIMOS PASOS:", :yellow
+        say "\n1. Configura las variables de entorno:", :cyan
+        say "   - Copia .env.example a .env (si usas dotenv)"
+        say "   - Configura las variables de AWS Cognito y Redis"
+        
+        say "\n2. Variables de entorno requeridas:", :cyan
+        say "   COGNITO_USER_POOL_ID=us-east-1_abcdef123"
+        say "   COGNITO_REGION=us-east-1"
+        say "   COGNITO_CLIENT_ID=tu-client-id"
+        
+        say "\n3. Variables de entorno opcionales:", :cyan
+        say "   COGNITO_CLIENT_SECRET=tu-client-secret (para mayor seguridad)"
+        say "   REDIS_TLS=true (para Redis con TLS)"
+        say "   REDIS_CA_CERT_PATH=/ruta/a/certificados"
+        
+        say "\n4. Reinicia tu aplicación Rails", :cyan
+        
+        say "\n📖 Documentación completa:", :yellow
+        say "   Revisa el README.md de la gema para ejemplos de uso"
+        say "\n" + "="*60, :blue
+      end
+
+      private
+
+      def env_variables
+        <<~ENV_VARS
+
+          # JWT Auth Cognito - Configuración
+          COGNITO_USER_POOL_ID=us-east-1_tu_user_pool_id
+          COGNITO_REGION=us-east-1
+          COGNITO_CLIENT_ID=tu_cognito_client_id
+          COGNITO_CLIENT_SECRET=tu_cognito_client_secret
+
+          # Redis para blacklist de tokens
+          REDIS_HOST=localhost
+          REDIS_PORT=6379
+          REDIS_PASSWORD=tu_redis_password
+          REDIS_DB=0
+          REDIS_TLS=false
+
+          # Redis TLS (para producción)
+          REDIS_CA_CERT_PATH=/ruta/a/certificados
+          REDIS_CA_CERT_NAME=redis-ca.crt
+          REDIS_TLS_MIN_VERSION=TLSv1.2
+          REDIS_TLS_MAX_VERSION=TLSv1.3
+
+          # Configuración adicional
+          JWKS_CACHE_TTL=3600
+        ENV_VARS
+      end
+
+      def rails_env_production?
+        defined?(Rails) && Rails.env.production?
+      end
+    end
+  end
+end

data/lib/generators/jwt_auth_cognito/templates/jwt_auth_cognito.rb.erb

@@ -0,0 +1,129 @@
+# frozen_string_literal: true
+
+# Configuración de JWT Auth Cognito
+# Generado automáticamente - puedes modificar según tus necesidades
+
+JwtAuthCognito.configure do |config|
+  # =============================================================================
+  # CONFIGURACIÓN DE AWS COGNITO
+  # =============================================================================
+  
+  # User Pool ID de tu Cognito (requerido)
+  config.cognito_user_pool_id = ENV['COGNITO_USER_POOL_ID']
+  
+  # Región de AWS donde está tu Cognito (requerido)
+  config.cognito_region = ENV['COGNITO_REGION'] || ENV['AWS_REGION'] || 'us-east-1'
+  
+  # Client ID de tu aplicación en Cognito (requerido para validación de audiencia)
+  config.cognito_client_id = ENV['COGNITO_CLIENT_ID']
+  
+  # Client Secret de tu aplicación en Cognito (opcional, para mayor seguridad)
+  # Si tu User Pool App Client está configurado con client secret, esto es requerido
+  config.cognito_client_secret = ENV['COGNITO_CLIENT_SECRET']
+
+  # =============================================================================
+  # CONFIGURACIÓN DE REDIS (para blacklist de tokens)
+  # =============================================================================
+  
+<% if defined?(Rails) && File.exist?(Rails.root.join('config', 'redis.yml')) -%>
+  # Integración con configuración existente de Redis
+  begin
+    redis_config = Rails.application.config_for(:redis)
+    config.redis_host = redis_config[:host] || ENV['REDIS_HOST'] || 'localhost'
+    config.redis_port = redis_config[:port] || ENV['REDIS_PORT']&.to_i || 6379
+    config.redis_password = redis_config[:password] || ENV['REDIS_PASSWORD']
+    config.redis_db = redis_config[:db] || ENV['REDIS_DB']&.to_i || 0
+    config.redis_ssl = redis_config[:ssl] || ENV['REDIS_TLS'] == 'true'
+  rescue StandardError
+    # Fallback si config/redis.yml no existe o tiene problemas
+<% end -%>
+    config.redis_host = ENV['REDIS_HOST'] || 'localhost'
+    config.redis_port = ENV['REDIS_PORT']&.to_i || 6379
+    config.redis_password = ENV['REDIS_PASSWORD']
+    config.redis_db = ENV['REDIS_DB']&.to_i || 0
+    config.redis_ssl = ENV['REDIS_TLS'] == 'true'
+<% if defined?(Rails) && File.exist?(Rails.root.join('config', 'redis.yml')) -%>
+  end
+<% end -%>
+  
+  # Configuración de timeouts para Redis
+  config.redis_timeout = ENV['REDIS_TIMEOUT']&.to_i || 5
+  config.redis_connect_timeout = ENV['REDIS_CONNECT_TIMEOUT']&.to_i || 10
+  config.redis_read_timeout = ENV['REDIS_READ_TIMEOUT']&.to_i || 10
+
+  # =============================================================================
+  # CONFIGURACIÓN TLS PARA REDIS (PRODUCCIÓN)
+  # =============================================================================
+  
+  # Configuración de certificados CA para Redis TLS
+  config.redis_ca_cert_path = ENV['REDIS_CA_CERT_PATH']
+  config.redis_ca_cert_name = ENV['REDIS_CA_CERT_NAME']
+  
+  # Control de versiones TLS
+  config.redis_tls_min_version = ENV['REDIS_TLS_MIN_VERSION'] || 'TLSv1.2'
+  config.redis_tls_max_version = ENV['REDIS_TLS_MAX_VERSION'] || 'TLSv1.3'
+  config.redis_verify_mode = ENV['REDIS_VERIFY_MODE'] || 'peer'
+
+  # =============================================================================
+  # CONFIGURACIÓN DE VALIDACIÓN
+  # =============================================================================
+  
+  # Modo de validación: :secure (producción) o :basic (desarrollo)
+  # - :secure: Validación completa con JWKS y verificación de firma
+  # - :basic: Validación básica sin verificación de firma (solo desarrollo)
+<% if defined?(Rails) -%>
+  config.validation_mode = Rails.env.production? ? :secure : :basic
+<% else -%>
+  config.validation_mode = ENV['RAILS_ENV'] == 'production' ? :secure : :basic
+<% end -%>
+  
+  # Tiempo de cache para claves JWKS (en segundos)
+  config.jwks_cache_ttl = ENV['JWKS_CACHE_TTL']&.to_i || 3600 # 1 hora
+end
+
+# =============================================================================
+# CONFIGURACIÓN ADICIONAL (OPCIONAL)
+# =============================================================================
+
+# Ejemplo de middleware para proteger rutas API
+# Descomenta y modifica según tus necesidades:
+#
+# class JwtCognitoMiddleware
+#   def initialize(app)
+#     @app = app
+#     @validator = JwtAuthCognito::JwtValidator.new
+#   end
+#
+#   def call(env)
+#     request = Rack::Request.new(env)
+#     
+#     # Solo validar en rutas API que requieren autenticación
+#     if request.path.start_with?('/api/secure/')
+#       token = @validator.extract_token_from_header(request.get_header('HTTP_AUTHORIZATION'))
+#       
+#       if token
+#         result = @validator.validate_access_token(token)
+#         if result[:valid]
+#           env['current_user_id'] = result[:sub]
+#           env['current_username'] = result[:username]
+#         else
+#           return unauthorized_response(result[:error])
+#         end
+#       else
+#         return unauthorized_response('Token de autorización requerido')
+#       end
+#     end
+#     
+#     @app.call(env)
+#   end
+#
+#   private
+#
+#   def unauthorized_response(error)
+#     body = { error: 'No autorizado', message: error }.to_json
+#     [401, { 'Content-Type' => 'application/json' }, [body]]
+#   end
+# end
+#
+# # Agregar el middleware a tu aplicación Rails:
+# Rails.application.config.middleware.use JwtCognitoMiddleware