HTTP, APIs y seguridad

func main() {
	mux := http.NewServeMux()

	// método + ruta + variables, directo en la stdlib (Go 1.22+)
	mux.HandleFunc("GET /productos", listarProductos)
	mux.HandleFunc("GET /productos/{id}", verProducto)
	mux.HandleFunc("POST /productos", crearProducto)

	log.Println("escuchando en :8080")
	log.Fatal(http.ListenAndServe(":8080", mux))
}

// Un handler: recibe writer y request. Esto es un @GetMapping sin anotaciones.
func verProducto(w http.ResponseWriter, r *http.Request) {
	id := r.PathValue("id") // la variable {id} de la ruta

	p, err := buscarProducto(id)
	if err != nil {
		http.Error(w, "no encontrado", http.StatusNotFound)
		return
	}

	w.Header().Set("Content-Type", "application/json")
	json.NewEncoder(w).Encode(p) // struct → JSON (tu Jackson integrado)
}

// Los tags del struct controlan el JSON, como @JsonProperty:
type Producto struct {
	ID      int     `json:"id"`
	Nombre  string  `json:"nombre"`
	Precio  float64 `json:"precio"`
	interno string  `json:"-"` // el guion lo excluye del JSON
}

// Un middleware es una función que envuelve un http.Handler y devuelve otro.
// Sin interfaces especiales, sin registro en contenedores: composición pura.
func conLog(next http.Handler) http.Handler {
	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		inicio := time.Now()
		next.ServeHTTP(w, r)
		log.Printf("%s %s (%v)", r.Method, r.URL.Path, time.Since(inicio))
	})
}

func conAuth(next http.Handler) http.Handler {
	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		if r.Header.Get("Authorization") == "" {
			http.Error(w, "no autorizado", http.StatusUnauthorized)
			return // corta la cadena, como filterChain sin doFilter
		}
		next.ServeHTTP(w, r)
	})
}

// Se encadenan como capas de cebolla:
handler := conLog(conAuth(mux))

import "golang.org/x/crypto/bcrypt"

// Al registrar: guarda el hash, jamás la contraseña
hash, err := bcrypt.GenerateFromPassword([]byte(password), bcrypt.DefaultCost)

// Al hacer login: compara en tiempo constante (inmune a timing attacks)
err = bcrypt.CompareHashAndPassword(hashGuardado, []byte(passwordRecibida))
if err != nil {
	// contraseña incorrecta: mismo mensaje genérico que "usuario no existe"
	http.Error(w, "credenciales inválidas", http.StatusUnauthorized)
	return
}

import "github.com/golang-jwt/jwt/v5"

var secreto = []byte(os.Getenv("JWT_SECRET"))

// Al hacer login, emite el token (tu TokenProvider de Spring Security):
func emitirToken(userID int) (string, error) {
	claims := jwt.MapClaims{
		"sub": userID,
		"exp": time.Now().Add(24 * time.Hour).Unix(),
		"iat": time.Now().Unix(),
	}
	return jwt.NewWithClaims(jwt.SigningMethodHS256, claims).SignedString(secreto)
}

// Middleware que protege rutas (tu JwtAuthenticationFilter):
func conJWT(next http.Handler) http.Handler {
	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		crudo := strings.TrimPrefix(r.Header.Get("Authorization"), "Bearer ")

		token, err := jwt.Parse(crudo, func(t *jwt.Token) (any, error) {
			return secreto, nil
		}, jwt.WithValidMethods([]string{"HS256"})) // rechaza alg:none y amigos

		if err != nil || !token.Valid {
			http.Error(w, "token inválido", http.StatusUnauthorized)
			return
		}
		next.ServeHTTP(w, r)
	})
}

// El middleware CORS que en Spring era @CrossOrigin, a mano y sin misterio:
func conCORS(next http.Handler) http.Handler {
	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		w.Header().Set("Access-Control-Allow-Origin", "http://localhost:5173")
		w.Header().Set("Access-Control-Allow-Methods", "GET, POST, PATCH, DELETE")
		w.Header().Set("Access-Control-Allow-Headers", "Authorization, Content-Type")

		if r.Method == http.MethodOptions { // preflight del navegador
			w.WriteHeader(http.StatusNoContent)
			return
		}
		next.ServeHTTP(w, r)
	})
}
// En producción: valida el Origin contra una lista blanca,
// o usa la lib rs/cors si prefieres no mantener esto.

import "golang.org/x/time/rate"

// Token bucket: 10 requests/segundo con ráfagas de hasta 20.
var limitador = rate.NewLimiter(10, 20)

func conLimite(next http.Handler) http.Handler {
	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		if !limitador.Allow() {
			http.Error(w, "demasiadas peticiones", http.StatusTooManyRequests)
			return
		}
		next.ServeHTTP(w, r)
	})
}
// Para límite POR IP: un map[string]*rate.Limiter protegido con mutex,
// limpiado periódicamente — 30 líneas; o usa la lib ulule/limiter.

import (
	"embed"
	"io/fs"
	"net/http"
	"strings"
)

// El resultado de `npm run build` copiado a frontend/dist:
//
//go:embed frontend/dist
var ui embed.FS

func spaHandler() http.Handler {
	dist, _ := fs.Sub(ui, "frontend/dist")
	archivos := http.FileServerFS(dist)

	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		ruta := strings.TrimPrefix(r.URL.Path, "/")

		// ¿El archivo existe (JS, CSS, imágenes)? Sírvelo tal cual.
		if _, err := fs.Stat(dist, ruta); err == nil && ruta != "" {
			archivos.ServeHTTP(w, r)
			return
		}
		// Si no existe, es una ruta de React Router (/perfil, /tareas/3):
		// devuelve index.html y deja que React tome el control.
		http.ServeFileFS(w, r, dist, "index.html")
	})
}

func main() {
	mux := http.NewServeMux()
	mux.Handle("GET /api/", http.StripPrefix("/api", rutasAPI())) // tu API
	mux.Handle("GET /", spaHandler())                              // tu React

	http.ListenAndServe(":8080", mux)
}