Practice 1 — CRUD, the easy way

1import "sync"
2
3type Task struct {
4	ID    int64  `json:"id"`
5	Title string `json:"title"`
6	Done  bool   `json:"done"`
7}
8
9// store holds every task. The mutex sits directly above what it guards.
10type store struct {
11	mu     sync.Mutex
12	tasks  map[int64]Task
13	nextID int64
14}
15
16func newStore() *store {
17	return &store{tasks: map[int64]Task{}, nextID: 1}
18}

1func (s *store) create(title string) Task {
2	s.mu.Lock()
3	defer s.mu.Unlock()
4
5	t := Task{ID: s.nextID, Title: title}
6	s.tasks[t.ID] = t
7	s.nextID++
8	return t
9}
10
11func (s *store) get(id int64) (Task, bool) {
12	s.mu.Lock()
13	defer s.mu.Unlock()
14
15	t, ok := s.tasks[id]      // the two-value form: absent is not the same as zero
16	return t, ok
17}
18
19func (s *store) list() []Task {
20	s.mu.Lock()
21	defer s.mu.Unlock()
22
23	out := make([]Task, 0, len(s.tasks))
24	for _, t := range s.tasks {
25		out = append(out, t)
26	}
27	// map order is random, so sort or the list jumps around between requests
28	slices.SortFunc(out, func(a, b Task) int { return cmp.Compare(a.ID, b.ID) })
29	return out
30}

1func (s *store) update(id int64, title *string, done *bool) (Task, bool) {
2	s.mu.Lock()
3	defer s.mu.Unlock()
4
5	t, ok := s.tasks[id]
6	if !ok {
7		return Task{}, false
8	}
9	if title != nil {          // nil means "the client did not send this field"
10		t.Title = *title
11	}
12	if done != nil {
13		t.Done = *done
14	}
15	s.tasks[id] = t
16	return t, true
17}
18
19func (s *store) delete(id int64) bool {
20	s.mu.Lock()
21	defer s.mu.Unlock()
22
23	if _, ok := s.tasks[id]; !ok {
24		return false            // report "not there" rather than pretending it worked
25	}
26	delete(s.tasks, id)
27	return true
28}

1func main() {
2	s := newStore()
3	mux := http.NewServeMux()
4
5	mux.HandleFunc("POST /tasks", s.handleCreate)
6	mux.HandleFunc("GET /tasks", s.handleList)
7	mux.HandleFunc("GET /tasks/{id}", s.handleGet)
8	mux.HandleFunc("PATCH /tasks/{id}", s.handleUpdate)
9	mux.HandleFunc("DELETE /tasks/{id}", s.handleDelete)
10
11	log.Println("listening on :8080")
12	// The simple version: no timeouts, and log.Fatal skips deferred calls.
13	// Fine for a practice app. The moderate CRUD practice uses http.Server
14	// with timeouts; "Middleware and graceful shutdown" adds a clean stop.
15	log.Fatal(http.ListenAndServe(":8080", mux))
16}
17
18func writeJSON(w http.ResponseWriter, status int, v any) {
19	w.Header().Set("Content-Type", "application/json")
20	w.WriteHeader(status)
21	if v != nil {
22		json.NewEncoder(w).Encode(v)
23	}
24}

1func (s *store) handleGet(w http.ResponseWriter, r *http.Request) {
2	id, err := strconv.ParseInt(r.PathValue("id"), 10, 64)
3	if err != nil {
4		writeJSON(w, 400, map[string]string{"error": "invalid id"})
5		return                 // always return after writing an error
6	}
7
8	t, ok := s.get(id)
9	if !ok {
10		writeJSON(w, 404, map[string]string{"error": "not found"})
11		return
12	}
13
14	writeJSON(w, 200, t)
15}