Wiring the Server

Practice

1. 1. Wiring the Server

   Intermediate

   You've written all five handlers. Now assemble them into a router so real requests reach them — and so {id} path values actually get populated.

   Implement (s *server) routes() *http.ServeMux registering:

   • GET /tasks → s.listTasks
   • POST /tasks → s.createTask
   • GET /tasks/{id} → s.getTask
   • PUT /tasks/{id} → s.updateTask
   • DELETE /tasks/{id} → s.deleteTask

   This is the moment the pieces become an API: the hidden test drives a full create → list → get → update → delete flow through your router. The {id} routes only work because the mux parses the pattern and fills PathValue — which is exactly why the handlers read r.PathValue("id").

   package main
   
   import (
   	"encoding/json"
   	"net/http"
   	"strconv"
   	"sync"
   )
   
   type Task struct {
   	ID       string `json:"id"`
   	Title    string `json:"title"`
   	Done     bool   `json:"done"`
   	Priority int    `json:"priority"`
   }
   
   // Store is the persistence seam the HTTP layer depends on. *TaskStore
   // satisfies it; a database-backed store could too, without touching handlers.
   type Store interface {
   	Create(title string, priority int) Task
   	Get(id string) (Task, bool)
   	List() []Task
   	Update(id, title string, done bool, priority int) (Task, bool)
   	Delete(id string) bool
   }
   
   type TaskStore struct {
   	mu     sync.Mutex
   	items  map[string]Task
   	order  []string
   	nextID int
   }
   
   func NewTaskStore() *TaskStore {
   	return &TaskStore{items: make(map[string]Task), nextID: 1}
   }
   
   func (s *TaskStore) Create(title string, priority int) Task {
   	s.mu.Lock()
   	defer s.mu.Unlock()
   	id := strconv.Itoa(s.nextID)
   	s.nextID++
   	t := Task{ID: id, Title: title, Done: false, Priority: priority}
   	s.items[id] = t
   	s.order = append(s.order, id)
   	return t
   }
   
   func (s *TaskStore) Get(id string) (Task, bool) {
   	s.mu.Lock()
   	defer s.mu.Unlock()
   	t, ok := s.items[id]
   	return t, ok
   }
   
   func (s *TaskStore) List() []Task {
   	s.mu.Lock()
   	defer s.mu.Unlock()
   	out := make([]Task, 0, len(s.order))
   	for _, id := range s.order {
   		out = append(out, s.items[id])
   	}
   	return out
   }
   
   func (s *TaskStore) Update(id, title string, done bool, priority int) (Task, bool) {
   	s.mu.Lock()
   	defer s.mu.Unlock()
   	if _, ok := s.items[id]; !ok {
   		return Task{}, false
   	}
   	t := Task{ID: id, Title: title, Done: done, Priority: priority}
   	s.items[id] = t
   	return t, true
   }
   
   func (s *TaskStore) Delete(id string) bool {
   	s.mu.Lock()
   	defer s.mu.Unlock()
   	if _, ok := s.items[id]; !ok {
   		return false
   	}
   	delete(s.items, id)
   	for i, oid := range s.order {
   		if oid == id {
   			s.order = append(s.order[:i], s.order[i+1:]...)
   			break
   		}
   	}
   	return true
   }
   
   func writeJSON(w http.ResponseWriter, status int, v any) {
   	w.Header().Set("Content-Type", "application/json")
   	w.WriteHeader(status)
   	json.NewEncoder(w).Encode(v)
   }
   
   func writeError(w http.ResponseWriter, status int, msg string) {
   	writeJSON(w, status, map[string]string{"error": msg})
   }
   
   func decodeJSON(w http.ResponseWriter, r *http.Request, dst any) bool {
   	dec := json.NewDecoder(r.Body)
   	dec.DisallowUnknownFields()
   	if err := dec.Decode(dst); err != nil {
   		writeError(w, http.StatusBadRequest, "invalid request body")
   		return false
   	}
   	return true
   }
   
   type server struct {
   	store Store
   }
   
   func (s *server) listTasks(w http.ResponseWriter, r *http.Request) {
   	writeJSON(w, http.StatusOK, s.store.List())
   }
   
   func (s *server) getTask(w http.ResponseWriter, r *http.Request) {
   	t, ok := s.store.Get(r.PathValue("id"))
   	if !ok {
   		writeError(w, http.StatusNotFound, "task not found")
   		return
   	}
   	writeJSON(w, http.StatusOK, t)
   }
   
   // validate returns a list of human-readable problems with the input,
   // or an empty slice if it is valid.
   func validate(title string, priority int) []string {
   	var problems []string
   	if title == "" {
   		problems = append(problems, "title must not be empty")
   	}
   	if priority < 1 || priority > 3 {
   		problems = append(problems, "priority must be between 1 and 3")
   	}
   	return problems
   }
   
   func (s *server) createTask(w http.ResponseWriter, r *http.Request) {
   	var in struct {
   		Title    string `json:"title"`
   		Priority int    `json:"priority"`
   	}
   	if !decodeJSON(w, r, &in) {
   		return
   	}
   	if problems := validate(in.Title, in.Priority); len(problems) > 0 {
   		writeJSON(w, http.StatusUnprocessableEntity, map[string][]string{"errors": problems})
   		return
   	}
   	t := s.store.Create(in.Title, in.Priority)
   	w.Header().Set("Location", "/tasks/"+t.ID)
   	writeJSON(w, http.StatusCreated, t)
   }
   
   func (s *server) updateTask(w http.ResponseWriter, r *http.Request) {
   	var in struct {
   		Title    string `json:"title"`
   		Done     bool   `json:"done"`
   		Priority int    `json:"priority"`
   	}
   	if !decodeJSON(w, r, &in) {
   		return
   	}
   	t, ok := s.store.Update(r.PathValue("id"), in.Title, in.Done, in.Priority)
   	if !ok {
   		writeError(w, http.StatusNotFound, "task not found")
   		return
   	}
   	writeJSON(w, http.StatusOK, t)
   }
   
   func (s *server) deleteTask(w http.ResponseWriter, r *http.Request) {
   	if !s.store.Delete(r.PathValue("id")) {
   		writeError(w, http.StatusNotFound, "task not found")
   		return
   	}
   	w.WriteHeader(http.StatusNoContent)
   }
   
   func (s *server) routes() *http.ServeMux {
   	mux := http.NewServeMux()
   	// TODO: register the five routes on s
   	return mux
   }
   
   func main() {
   	http.ListenAndServe(":8080", (&server{store: NewTaskStore()}).routes())
   }
   
   

   Sign in to write and run your solution in the browser.

   Sign in for hints and the solution.