Category: Golang

type List[E any] []E

List[int]
List[string]

func (list List[E]) Map[R any](transform func(E) R) List[R] {
    result := make(List[R], len(list))

    for i, element := range list {
        result[i] = transform(element)
    } 

    return result
}

numbers := List[int]{1, 2, 3}

strings := numbers.Map(func(number int) string {
    return strconv.Itoa(number)
})

fmt.Println(strings) // [1 2 3]

List[int] > List[string]

func (list List[E]) First() E {
    return list[0]
}

func (list List[E]) Map[R any](...) List[R]

package main

import (
	"net/http"
	"strings"
	"time"

	"github.com/gin-gonic/gin"
	"github.com/golang-jwt/jwt/v5"
)

// --- Config

var jwtSecret = []byte("super-secret-key-change-me-in-prod")

// Hardcoded users
var users = map[string]string{
	"alberto": "password123",
	"admin":   "admin",
}

// --- JWT helpers

type Claims struct {
	Username string `json:"username"`
	jwt.RegisteredClaims
}

func generateToken(username string) (string, error) {
	claims := Claims{
		Username: username,
		RegisteredClaims: jwt.RegisteredClaims{
			ExpiresAt: jwt.NewNumericDate(time.Now().Add(1 * time.Hour)),
			IssuedAt:  jwt.NewNumericDate(time.Now()),
			Issuer:    "jwt-demo",
		},
	}
	token := jwt.NewWithClaims(jwt.SigningMethodHS256, claims)
	return token.SignedString(jwtSecret)
}

func parseToken(raw string) (*Claims, error) {
	token, err := jwt.ParseWithClaims(raw, &Claims{}, func(t *jwt.Token) (any, error) {
		if _, ok := t.Method.(*jwt.SigningMethodHMAC); !ok {
			return nil, jwt.ErrSignatureInvalid
		}
		return jwtSecret, nil
	})
	if err != nil {
		return nil, err
	}
	claims, ok := token.Claims.(*Claims)
	if !ok || !token.Valid {
		return nil, jwt.ErrTokenInvalidClaims
	}
	return claims, nil
}

// --- Middleware

func authMiddleware() gin.HandlerFunc {
	return func(c *gin.Context) {
		authHeader := c.GetHeader("Authorization")
		if authHeader == "" || !strings.HasPrefix(authHeader, "Bearer ") {
			c.AbortWithStatusJSON(http.StatusUnauthorized, gin.H{
				"error": "missing or malformed Authorization header",
			})
			return
		}

		raw := strings.TrimPrefix(authHeader, "Bearer ")
		claims, err := parseToken(raw)
		if err != nil {
			c.AbortWithStatusJSON(http.StatusUnauthorized, gin.H{
				"error": "invalid or expired token",
			})
			return
		}

		// Stash the username for downstream handlers.
		c.Set("username", claims.Username)
		c.Next()
	}
}

// --- Handlers

type LoginRequest struct {
	Username string `json:"username" binding:"required"`
	Password string `json:"password" binding:"required"`
}

// POST /auth
func handleAuth(c *gin.Context) {
	var req LoginRequest
	if err := c.ShouldBindJSON(&req); err != nil {
		c.JSON(http.StatusBadRequest, gin.H{"error": "username and password are required"})
		return
	}

	expected, ok := users[req.Username]
	if !ok || expected != req.Password {
		c.JSON(http.StatusUnauthorized, gin.H{"error": "invalid credentials"})
		return
	}

	token, err := generateToken(req.Username)
	if err != nil {
		c.JSON(http.StatusInternalServerError, gin.H{"error": "could not generate token"})
		return
	}

	c.JSON(http.StatusOK, gin.H{
		"token":      token,
		"expires_in": "1h",
	})
}

// GET /secret_data
func handleSecretData(c *gin.Context) {
	username, _ := c.Get("username")
	c.JSON(http.StatusOK, gin.H{
		"message": "Welcome to the secret vault!",
		"user":    username,
		"secrets": []string{
			"secret one",
			"secret two",
			"secret three",
		},
	})
}

// --- Main

func main() {
	r := gin.Default()

	r.POST("/auth", handleAuth)

	protected := r.Group("/")
	protected.Use(authMiddleware())
	{
		protected.GET("/secret_data", handleSecretData)
	}

	r.Run(":8080") // listen on http://localhost:8080
}

curl -X POST http://localhost:8080/auth -H "Content-Type: application/json"  -d '{"username":"alberto", "password":"password123"}'

TOKEN="<...>"
curl http://localhost:8080/secret_data  -H "Authorization: Bearer $TOKEN"