Build a JSON Task API

package main

import (
    "encoding/json"
    "log"
    "net/http"
    "sort"
    "strconv"
    "sync"

    "github.com/gorilla/mux"
)

// Task is one item in the list.
type Task struct {
    ID    int    `json:"id"`
    Title string `json:"title"`
    Done  bool   `json:"done"`
}

// store holds the tasks in memory. Every request runs in its own goroutine,
// so the map is guarded by a mutex.
type store struct {
    mu     sync.Mutex
    tasks  map[int]Task
    nextID int
}

func newStore() *store {
    return &store{
        tasks: map[int]Task{
            1: {ID: 1, Title: "Write the handler", Done: true},
            2: {ID: 2, Title: "Add the router", Done: false},
        },
        nextID: 3,
    }
}

func (s *store) list() []Task {
    s.mu.Lock()
    defer s.mu.Unlock()

    out := make([]Task, 0, len(s.tasks))
    for _, t := range s.tasks {
        out = append(out, t)
    }
    sort.Slice(out, func(i, j int) bool { return out[i].ID < out[j].ID })
    return out
}

func (s *store) get(id int) (Task, bool) {
    s.mu.Lock()
    defer s.mu.Unlock()

    t, ok := s.tasks[id]
    return t, ok
}

func (s *store) add(title string) Task {
    s.mu.Lock()
    defer s.mu.Unlock()

    t := Task{ID: s.nextID, Title: title}
    s.tasks[t.ID] = t
    s.nextID++
    return t
}

func (s *store) replace(id int, title string, done bool) (Task, bool) {
    s.mu.Lock()
    defer s.mu.Unlock()

    if _, ok := s.tasks[id]; !ok {
        return Task{}, false
    }
    t := Task{ID: id, Title: title, Done: done}
    s.tasks[id] = t
    return t, true
}

func (s *store) remove(id int) bool {
    s.mu.Lock()
    defer s.mu.Unlock()

    if _, ok := s.tasks[id]; !ok {
        return false
    }
    delete(s.tasks, id)
    return true
}

// writeJSON sends v with the right content type and status.
func writeJSON(w http.ResponseWriter, status int, v any) {
    w.Header().Set("Content-Type", "application/json")
    w.WriteHeader(status)
    json.NewEncoder(w).Encode(v)
}

// idFrom reads the {id} placeholder mux captured from the path.
func idFrom(r *http.Request) (int, error) {
    return strconv.Atoi(mux.Vars(r)["id"])
}

type api struct{ store *store }

func (a *api) listTasks(w http.ResponseWriter, r *http.Request) {
    writeJSON(w, http.StatusOK, a.store.list())
}

func (a *api) getTask(w http.ResponseWriter, r *http.Request) {
    id, err := idFrom(r)
    if err != nil {
        writeJSON(w, http.StatusBadRequest, map[string]string{"error": "id must be a number"})
        return
    }

    t, ok := a.store.get(id)
    if !ok {
        writeJSON(w, http.StatusNotFound, map[string]string{"error": "no such task"})
        return
    }
    writeJSON(w, http.StatusOK, t)
}

func (a *api) createTask(w http.ResponseWriter, r *http.Request) {
    var in Task
    if err := json.NewDecoder(r.Body).Decode(&in); err != nil {
        writeJSON(w, http.StatusBadRequest, map[string]string{"error": "body must be JSON"})
        return
    }
    if in.Title == "" {
        writeJSON(w, http.StatusUnprocessableEntity, map[string]string{"error": "title is required"})
        return
    }

    t := a.store.add(in.Title)
    w.Header().Set("Location", "/tasks/"+strconv.Itoa(t.ID))
    writeJSON(w, http.StatusCreated, t)
}

func (a *api) updateTask(w http.ResponseWriter, r *http.Request) {
    id, err := idFrom(r)
    if err != nil {
        writeJSON(w, http.StatusBadRequest, map[string]string{"error": "id must be a number"})
        return
    }

    var in Task
    if err := json.NewDecoder(r.Body).Decode(&in); err != nil {
        writeJSON(w, http.StatusBadRequest, map[string]string{"error": "body must be JSON"})
        return
    }

    t, ok := a.store.replace(id, in.Title, in.Done)
    if !ok {
        writeJSON(w, http.StatusNotFound, map[string]string{"error": "no such task"})
        return
    }
    writeJSON(w, http.StatusOK, t)
}

func (a *api) deleteTask(w http.ResponseWriter, r *http.Request) {
    id, err := idFrom(r)
    if err != nil {
        writeJSON(w, http.StatusBadRequest, map[string]string{"error": "id must be a number"})
        return
    }

    if !a.store.remove(id) {
        writeJSON(w, http.StatusNotFound, map[string]string{"error": "no such task"})
        return
    }
    w.WriteHeader(http.StatusNoContent)
}

// logging wraps every handler, so one line is printed per request.
func logging(next http.Handler) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        log.Printf("%s %s", r.Method, r.URL.Path)
        next.ServeHTTP(w, r)
    })
}

func main() {
    a := &api{store: newStore()}

    r := mux.NewRouter()
    r.Use(logging)

    r.HandleFunc("/tasks", a.listTasks).Methods(http.MethodGet)
    r.HandleFunc("/tasks", a.createTask).Methods(http.MethodPost)
    r.HandleFunc("/tasks/{id:[0-9]+}", a.getTask).Methods(http.MethodGet)
    r.HandleFunc("/tasks/{id:[0-9]+}", a.updateTask).Methods(http.MethodPut)
    r.HandleFunc("/tasks/{id:[0-9]+}", a.deleteTask).Methods(http.MethodDelete)

    log.Println("listening on :8090")
    log.Fatal(http.ListenAndServe(":8090", r))
}