Practice 2 — CRUD, split into layers

1CREATE TABLE tasks (
2  id         BIGSERIAL PRIMARY KEY,
3  title      TEXT NOT NULL,
4  done       BOOLEAN NOT NULL DEFAULT false,
5  created_at TIMESTAMPTZ NOT NULL DEFAULT now()
6);

1package task
2
3type Store struct{ db *sql.DB }
4
5func NewStore(db *sql.DB) *Store { return &Store{db: db} }
6
7func (s *Store) Create(ctx context.Context, t *Task) error {
8	return s.db.QueryRowContext(ctx,
9		`INSERT INTO tasks (title) VALUES ($1) RETURNING id, done, created_at`,
10		t.Title,
11	).Scan(&t.ID, &t.Done, &t.CreatedAt)
12}
13
14func (s *Store) GetByID(ctx context.Context, id int64) (*Task, error) {
15	var t Task
16	err := s.db.QueryRowContext(ctx,
17		`SELECT id, title, done, created_at FROM tasks WHERE id = $1`, id,
18	).Scan(&t.ID, &t.Title, &t.Done, &t.CreatedAt)
19
20	if errors.Is(err, sql.ErrNoRows) {
21		return nil, ErrNotFound        // translate to OUR error, not the driver's
22	}
23	if err != nil {
24		return nil, err
25	}
26	return &t, nil
27}
28
29func (s *Store) Delete(ctx context.Context, id int64) error {
30	res, err := s.db.ExecContext(ctx, `DELETE FROM tasks WHERE id = $1`, id)
31	if err != nil {
32		return err
33	}
34	if n, _ := res.RowsAffected(); n == 0 {
35		return ErrNotFound
36	}
37	return nil
38}

1package api
2
3type Handler struct{ tasks *task.Store }
4
5func NewHandler(t *task.Store) *Handler { return &Handler{tasks: t} }
6
7func (h *Handler) get(w http.ResponseWriter, r *http.Request) {
8	id, err := strconv.ParseInt(r.PathValue("id"), 10, 64)
9	if err != nil {
10		ErrorJSON(w, 400, "invalid id")
11		return
12	}
13
14	t, err := h.tasks.GetByID(r.Context(), id)   // pass the request context down
15	if err != nil {
16		fromError(w, err)                        // one place maps errors to statuses
17		return
18	}
19
20	WriteJSON(w, 200, t)
21}
22
23// fromError is the only function that decides HTTP status codes.
24func fromError(w http.ResponseWriter, err error) {
25	switch {
26	case errors.Is(err, task.ErrNotFound):
27		ErrorJSON(w, 404, "not found")
28	case errors.Is(err, task.ErrValidation):
29		ErrorJSON(w, 422, err.Error())
30	default:
31		slog.Error("unhandled", "err", err)
32		ErrorJSON(w, 500, "internal server error")
33	}
34}

1func main() {
2	if err := run(); err != nil {
3		slog.Error("fatal", "err", err)
4		os.Exit(1)              // one exit, at the top, so every defer still runs
5	}
6}
7
8func run() error {
9	db, err := database.Open(os.Getenv("DATABASE_URL"))
10	if err != nil {
11		return err
12	}
13	defer db.Close()
14
15	store := task.NewStore(db)      // build from the inside out
16	h := api.NewHandler(store)
17
18	mux := http.NewServeMux()
19	h.Routes(mux)
20
21	srv := &http.Server{
22		Addr:              ":8080",
23		Handler:           mux,
24		ReadHeaderTimeout: 5 * time.Second,
25		ReadTimeout:       15 * time.Second,
26		WriteTimeout:      30 * time.Second,
27	}
28	return srv.ListenAndServe()
29}