Context & Passing Data from Middleware

package main

import (
  "context"
  "fmt"
)

// A custom key type — prevents collisions between packages.
type contextKey string

func main() {
  // 1) Every context starts from the "background" — an empty root.
  ctx := context.Background()

  // 2) WithValue creates a NEW context (the old one is unchanged).
  userIDKey := contextKey("userID")
  ctx = context.WithValue(ctx, userIDKey, 42)

  // 3) Value() returns interface{} — use type assertion to get the int.
  val, ok := ctx.Value(userIDKey).(int)
  if !ok {
      fmt.Println("key not found!")
      return
  }
  fmt.Printf("userID = %d\n", val)

  // 4) What if we use the wrong type in the assertion?
  _, ok2 := ctx.Value(userIDKey).(string) // stored as int, asserting as string
  fmt.Printf("ok2 = %v (expected false)\n", ok2)

  // 5) What if we look up a key that was never stored?
  _, ok3 := ctx.Value(contextKey("missing")).(int)
  fmt.Printf("ok3 = %v (expected false)\n", ok3)
}

go run play.go

// Custom type for context keys — prevents collisions.
type contextKey string
const ctxKeyUsername contextKey = "username"

func authMiddleware(next http.Handler) http.Handler {
  return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
      // 1) Get the existing context from the request
      ctx := r.Context()

      // 2) Create a new context with our value added
      //    (real auth would parse a token/header here)
      ctx = context.WithValue(ctx, ctxKeyUsername, "alice")

      // 3) Create a new request that carries the updated context
      r = r.WithContext(ctx)

      // 4) Pass the enriched request to the next handler
      next.ServeHTTP(w, r)
  })
}

func whoami(w http.ResponseWriter, r *http.Request) {
  username, ok := r.Context().Value(ctxKeyUsername).(string)
  if !ok {
      http.Error(w, "unauthorized", http.StatusUnauthorized)
      return
  }
  fmt.Fprintf(w, "Hello, %s!\n", username)
}

package main

import (
  "context"
  "encoding/json"
  "fmt"
  "log"
  "net/http"
  "time"
)

// --- Context keys ---

type contextKey string
const ctxKeyUsername contextKey = "username"

// --- Middleware ---

func loggingMiddleware(next http.Handler) http.Handler {
  return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
      start := time.Now()
      log.Printf("→ %s %s", r.Method, r.URL.Path)
      next.ServeHTTP(w, r)
      log.Printf("← %s %s (%v)", r.Method, r.URL.Path, time.Since(start))
  })
}

func authMiddleware(next http.Handler) http.Handler {
  return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
      // Pretend we authenticated the user.
      // Real code would check an Authorization header here.
      ctx := context.WithValue(r.Context(), ctxKeyUsername, "alice")
      next.ServeHTTP(w, r.WithContext(ctx))
  })
}

// --- Data ---

type User struct {
  ID        int       `json:"id"`
  Name      string    `json:"name"`
  Email     string    `json:"email"`
  CreatedAt time.Time `json:"created_at"`
}

var users = []User{
  {ID: 1, Name: "Alice", Email: "alice@example.com", CreatedAt: time.Now()},
  {ID: 2, Name: "Bob", Email: "bob@example.com", CreatedAt: time.Now()},
}

// --- Handlers ---

func getUsers(w http.ResponseWriter, r *http.Request) {
  w.Header().Set("Content-Type", "application/json")
  json.NewEncoder(w).Encode(users)
}

func whoami(w http.ResponseWriter, r *http.Request) {
  // Read the username that authMiddleware stored in the context.
  username, ok := r.Context().Value(ctxKeyUsername).(string)
  if !ok {
      http.Error(w, "unauthorized", http.StatusUnauthorized)
      return
  }
  fmt.Fprintf(w, "Hello, %s!\n", username)
}

// --- Main ---

func main() {
  mux := http.NewServeMux()
  mux.HandleFunc("GET /whoami", whoami)
  mux.HandleFunc("GET /users", getUsers)

  // Layer: auth → logging → mux
  // The onion: authMiddleware runs first, then loggingMiddleware, then mux.
  handler := authMiddleware(loggingMiddleware(mux))

  log.Println("Server starting on http://localhost:8080")
  log.Fatal(http.ListenAndServe(":8080", handler))
}

go run main.go

# /whoami reads the username from context (placed by auth middleware)
curl http://localhost:8080/whoami

# /users doesn't use context — it still works fine
curl http://localhost:8080/users