Practice 3 — CRUD, one folder per feature

1handler.go    imports  net/http   +  service
2service.go    imports  the repository interface it declares itself
3repository.go imports  database/sql
4
5// and never the reverse: no arrow points back up

1package user
2
3type User struct {
4	ID           int64     `json:"id"`
5	Name         string    `json:"name"`
6	Email        string    `json:"email"`
7	PasswordHash string    `json:"-"`          // never leaves the server
8	CreatedAt    time.Time `json:"created_at"`
9}
10
11// CreateRequest is what a client is allowed to send. It is NOT
12// the User type, so nobody can post an "id" or a "password_hash".
13type CreateRequest struct {
14	Name  string `json:"name"`
15	Email string `json:"email"`
16}
17
18func (r CreateRequest) Validate() error {
19	if strings.TrimSpace(r.Name) == "" {
20		return fmt.Errorf("%w: name is required", ErrValidation)
21	}
22	if !strings.Contains(r.Email, "@") {
23		return fmt.Errorf("%w: a valid email is required", ErrValidation)
24	}
25	return nil
26}

1type Repository struct{ db *sql.DB }
2
3func NewRepository(db *sql.DB) *Repository { return &Repository{db: db} }
4
5func (r *Repository) Create(ctx context.Context, u *User) error {
6	return r.db.QueryRowContext(ctx,
7		`INSERT INTO users (name, email, password_hash)
8		 VALUES ($1, $2, $3) RETURNING id, created_at`,
9		u.Name, u.Email, u.PasswordHash,
10	).Scan(&u.ID, &u.CreatedAt)
11}
12
13func (r *Repository) Delete(ctx context.Context, id int64) error {
14	res, err := r.db.ExecContext(ctx, `DELETE FROM users WHERE id = $1`, id)
15	if err != nil {
16		return err
17	}
18	if n, _ := res.RowsAffected(); n == 0 {
19		return ErrNotFound
20	}
21	return nil
22}

1// Store is declared HERE, by the code that uses it — not next to the type
2// that implements it. That way it is exactly as big as this service needs,
3// and a test fake has two methods to write instead of fifteen.
4type Store interface {
5	Create(ctx context.Context, u *User) error
6	GetByID(ctx context.Context, id int64) (*User, error)
7}
8
9type Service struct{ repo Store }
10
11func NewService(r Store) *Service { return &Service{repo: r} }
12
13func (s *Service) Create(ctx context.Context, req CreateRequest) (*User, error) {
14	if err := req.Validate(); err != nil {
15		return nil, err
16	}
17	u := &User{Name: req.Name, Email: strings.ToLower(req.Email)}   // a rule
18	if err := s.repo.Create(ctx, u); err != nil {
19		return nil, err
20	}
21	return u, nil
22}

1type Handler struct{ svc *Service }
2
3func (h *Handler) Routes(mux *http.ServeMux) {
4	mux.HandleFunc("POST /users", h.create)
5	mux.HandleFunc("GET /users", h.list)
6	mux.HandleFunc("GET /users/{id}", h.get)
7	mux.HandleFunc("PATCH /users/{id}", h.update)
8	mux.HandleFunc("DELETE /users/{id}", h.delete)
9}
10
11func (h *Handler) get(w http.ResponseWriter, r *http.Request) {
12	id, err := strconv.ParseInt(r.PathValue("id"), 10, 64)
13	if err != nil {
14		httpx.Error(w, 400, "invalid id")
15		return
16	}
17
18	u, err := h.svc.GetByID(r.Context(), id)
19	if err != nil {
20		httpx.FromError(w, err)
21		return
22	}
23
24	httpx.JSON(w, 200, u)
25}

1func run() error {
2	cfg, err := config.Load()
3	if err != nil {
4		return err
5	}
6
7	db, err := database.Open(cfg.DatabaseURL)
8	if err != nil {
9		return err
10	}
11	defer db.Close()
12
13	userRepo := user.NewRepository(db)      // inside
14	userSvc := user.NewService(userRepo)    // middle
15	userH := user.NewHandler(userSvc)       // outside
16
17	noteRepo := note.NewRepository(db)
18	noteSvc := note.NewService(noteRepo)
19	noteH := note.NewHandler(noteSvc)
20
21	mux := http.NewServeMux()
22	userH.Routes(mux)
23	noteH.Routes(mux)
24
25	handler := middleware.Chain(mux, middleware.Recover, middleware.RequestID, middleware.Logger)
26	return serve(cfg.Port, handler)
27}