Implementando el middleware

Contenido del curso

Introducción

REST

WebSockets

Cierre

Tomar examen

Cursos Empresas Blog Live Conf Eventos Precios

0:0010:19

Implementando el middleware

Curso de Go Avanzado: REST y WebSockets

Clase 16 de 26

Clase 16 / 26

Gregory Taveras Ramirez

Hace 4 meses

Dos observaciones

1 - El token debe mandarse en el tap de Authorization en postman como un Bearer Token.

2 - hay Código en el Handler que es funcionalidad del Middleware

quedaría así:

Middleware

package middleware

import (
	"context"
	"net/http"
	"strings"

	"github.com/golang-jwt/jwt"
	"platzi.com/go/rest-ws/models"
	"platzi.com/go/rest-ws/server"
)

var NO_AUTH_NEEDED = []string{
	"login",
	"signup",
}

// Definimos un tipo personalizado para la clave del contexto para evitar colisiones
type contextKey string
const ClaimsKey contextKey = "claims"

func shouldCheckToken(route string) bool {
	for _, p := range NO_AUTH_NEEDED {
		if strings.Contains(route, p) {
			return false
		}
	}
	return true
}

func CheckAuthMiddleware(s server.Server) func(h http.Handler) http.Handler {
	return func(next http.Handler) http.Handler {
		return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
			if !shouldCheckToken(r.URL.Path) {
				next.ServeHTTP(w, r)
				return
			}

			tokenString := strings.TrimSpace(r.Header.Get("Authorization"))
			
			// Parseamos y extraemos los claims de una vez
			token, err := jwt.ParseWithClaims(tokenString, &models.AppClaims{}, func(token *jwt.Token) (interface{}, error) {
				return []byte(s.Config().JWTSecret), nil
			})

			if err != nil || !token.Valid {
				http.Error(w, "Unauthorized: Invalid or missing token", http.StatusUnauthorized)
				return
			}

			if claims, ok := token.Claims.(*models.AppClaims); ok {
				// 💡 Aquí está el truco: Pasamos los claims al contexto de la petición
				ctx := context.WithValue(r.Context(), ClaimsKey, claims)
				next.ServeHTTP(w, r.WithContext(ctx))
				return
			}

			http.Error(w, "Unauthorized", http.StatusUnauthorized)
		})
	}
}

Handler

func MeHandler(s server.Server) http.HandlerFunc {
	return func(w http.ResponseWriter, r *http.Request) {
		// 1. Extraemos los claims que el middleware ya guardó en el contexto
		claims, ok := r.Context().Value(middleware.ClaimsKey).(*models.AppClaims)
		if !ok {
			http.Error(w, "Internal Server Error: Claims not found", http.StatusInternalServerError)
			return
		}

		// 2. Buscamos al usuario usando el UserId de los claims
		user, err := repository.GetUserByID(r.Context(), claims.UserId)
		if err != nil {
			http.Error(w, err.Error(), http.StatusInternalServerError)
			return
		}

		// 3. Respondemos con el usuario
		w.Header().Set("Content-Type", "application/json")
		json.NewEncoder(w).Encode(user)
	}
}

Comentarios (10)10 comentarios

Christian Gonzalo Espinoza Cadillo

Hace 4 años

Jonathan Stiven Colorado Largo

Hace 3 años

NELSON ARLEY USUGA MONCADA

Carlos Nexans

Victor Baruch Pazaran Jaimes

Àlex Grau Roca

Oscar Gómez Rodríguez

Hace 2 años

Edwin García

Matias Niz

Heiner Ríos Rodríguez

Carlos Eduardo Magallon Zepeda

Luis Alfredo Hernández Duarte

Carlos Arturo Pimentel

Introducción

Introducción al curso

¿Qué estaremos construyendo?

HTTP y REST

CRUD

REST

Inicialización de módulo e instalación de dependencias

Struct Server

Nuestro primer endpoint

Definiendo el modelo de usuarios

Patrón repository

Registro de usuarios

Implementando el registro

Probando los registros

Autenticación de usuarios

Probando el login

Middleware de validación de autenticación

Implementando el middleware

Modelo Posts

CRUD para Posts

Paginación para Posts

WebSockets

Websockets

Upgrader y Endpoint para Websocket

Struct de Hub para conexiones

Implementando el Broadcast

Cierre

Ejemplo de implementación frontend

Docker file para producción

Siguientes pasos y mejoras

Implementando el middleware

Progreso del curso

Introducción

REST

WebSockets

Cierre