net/http: a server with no framework

package main

import (
    "context"
    "encoding/json"
    "errors"
    "log"
    "net/http"
    "os"
    "os/signal"
    "sync"
    "syscall"
    "time"
)

type Note struct {
    ID   int    `json:"id"`
    Text string `json:"text"`
}

type store struct {
    mu     sync.RWMutex
    notes  map[int]Note
    nextID int
}

func newStore() *store {
    return &store{notes: map[int]Note{}, nextID: 1}
}

func (s *store) list() []Note {
    s.mu.RLock()
    defer s.mu.RUnlock()
    out := make([]Note, 0, len(s.notes))
    for _, n := range s.notes {
        out = append(out, n)
    }
    return out
}

func (s *store) add(text string) Note {
    s.mu.Lock()
    defer s.mu.Unlock()
    n := Note{ID: s.nextID, Text: text}
    s.notes[n.ID] = n
    s.nextID++
    return n
}

// One helper for every JSON response, so the header is never forgotten.
func writeJSON(w http.ResponseWriter, status int, v any) {
    w.Header().Set("Content-Type", "application/json")
    w.WriteHeader(status)
    if err := json.NewEncoder(w).Encode(v); err != nil {
        log.Printf("encoding response: %v", err)
    }
}

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

func recoverer(next http.Handler) http.Handler {
    return http.HandlerFunc(
        func(w http.ResponseWriter, r *http.Request) {
        defer func() {
            if rec := recover(); rec != nil {
                log.Printf("panic: %v", rec)
                writeJSON(w, http.StatusInternalServerError,
                    map[string]string{"error": "internal error"})
            }
        }()
        next.ServeHTTP(w, r)
    })
}

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

    mux.HandleFunc("GET /notes",
        func(w http.ResponseWriter, r *http.Request) {
        writeJSON(w, http.StatusOK, s.list())
    })

    mux.HandleFunc("POST /notes",
        func(w http.ResponseWriter, r *http.Request) {
        var in struct {
            Text string `json:"text"`
        }
        dec := json.NewDecoder(http.MaxBytesReader(w, r.Body, 1<<20))
        dec.DisallowUnknownFields()
        if err := dec.Decode(&in); err != nil {
            writeJSON(w, http.StatusBadRequest,
                map[string]string{"error": "invalid json"})
            return
        }
        if in.Text == "" {
            writeJSON(w, http.StatusUnprocessableEntity,
                map[string]string{"text": "must not be empty"})
            return
        }
        writeJSON(w, http.StatusCreated, s.add(in.Text))
    })

    mux.HandleFunc("GET /panic",
        func(w http.ResponseWriter, r *http.Request) {
        panic("deliberate")      // proves the recoverer works
    })

    srv := &http.Server{
        Addr:              ":8080",
        Handler:           logger(recoverer(mux)),
        ReadHeaderTimeout: 5 * time.Second,
        ReadTimeout:       15 * time.Second,
        WriteTimeout:      15 * time.Second,
        IdleTimeout:       60 * time.Second,
    }

    go func() {
        if err := srv.ListenAndServe(); err != nil &&
            !errors.Is(err, http.ErrServerClosed) {
            log.Fatalf("listen: %v", err)
        }
    }()
    log.Println("listening on :8080")

    stop := make(chan os.Signal, 1)
    signal.Notify(stop, os.Interrupt, syscall.SIGTERM)
    <-stop

    ctx, cancel := context.WithTimeout(
        context.Background(), 10*time.Second)
    defer cancel()
    if err := srv.Shutdown(ctx); err != nil {
        log.Printf("forced: %v", err)
    }
    log.Println("stopped cleanly")
}

curl localhost:8080/notes
curl -X POST localhost:8080/notes -d '{"text":"buy milk"}'
# 400, unknown field
curl -X POST localhost:8080/notes -d '{"txt":"typo"}'
curl -X POST localhost:8080/notes -d '{"text":""}'        # 422
# 405, automatic
curl -X DELETE localhost:8080/notes
# 500, and the server survives
curl localhost:8080/panic