Step 3 — Creating a short link

1touch internal/service/code.go internal/service/shortener.go internal/transport/web/handler.go
2
3go build ./... && go run ./cmd/api
4
5# in a second terminal — the happy path
6curl -s -X POST localhost:8080/links -d '{"url":"https://go.dev/doc/"}' | jq
7
8# and the failures
9curl -s -X POST localhost:8080/links -d '{"url":""}'
10curl -s -X POST localhost:8080/links -d '{"url":"hello"}'
11curl -s -X POST localhost:8080/links -d '{"url":"javascript:alert(1)"}'
12curl -s -X POST localhost:8080/links -d 'not json'

1package service
2
3import (
4	"crypto/rand"
5	"math/big"
6)
7
8// No 0/O or 1/l/I — they are easy to misread when somebody types a code by hand.
9const alphabet = "abcdefghijkmnopqrstuvwxyzABCDEFGHJKLMNPQRSTUVWXYZ23456789"
10
11// NewCode returns a random code of n characters.
12func NewCode(n int) (string, error) {
13	b := make([]byte, n)
14	max := big.NewInt(int64(len(alphabet)))
15
16	for i := range b {
17		k, err := rand.Int(rand.Reader, max)   // crypto/rand, not math/rand
18		if err != nil {
19			return "", err
20		}
21		b[i] = alphabet[k.Int64()]
22	}
23	return string(b), nil
24}

1package service
2
3import (
4	"context"
5	"errors"
6	"fmt"
7	"time"
8
9	"github.com/you/shortener/internal/model"
10)
11
12// Store is declared HERE, by the layer that uses it — not by the store package.
13// It is exactly as big as this service needs, so a test fake has two methods.
14type Store interface {
15	// ctx comes first: if the request is cancelled, the query stops too.
16	Save(ctx context.Context, l *model.Link) error
17	ByCode(ctx context.Context, code string) (*model.Link, error)
18}
19
20type Service struct{ store Store }
21
22func New(s Store) *Service { return &Service{store: s} }
23
24func (s *Service) Shorten(ctx context.Context, raw string) (*model.Link, error) {
25	long, err := validateURL(raw)
26	if err != nil {
27		return nil, err
28	}
29
30	// Codes are random, so a clash is possible. Try a few times rather than
31	// failing the request on bad luck.
32	for attempt := 0; attempt < 5; attempt++ {
33		code, err := NewCode(6)
34		if err != nil {
35			return nil, err
36		}
37
38		l := &model.Link{Code: code, LongURL: long, CreatedAt: time.Now()}
39		err = s.store.Save(ctx, l)
40		if err == nil {
41			return l, nil
42		}
43		if !errors.Is(err, model.ErrCodeTaken) {
44			return nil, err        // a real failure, not a clash
45		}
46	}
47	return nil, fmt.Errorf("could not generate a free code")
48}

1func validateURL(raw string) (string, error) {
2	raw = strings.TrimSpace(raw)
3	if raw == "" {
4		return "", fmt.Errorf("%w: url is required", ErrValidation)
5	}
6	if len(raw) > 2048 {
7		return "", fmt.Errorf("%w: url is too long", ErrValidation)
8	}
9
10	u, err := url.Parse(raw)
11	if err != nil {
12		return "", fmt.Errorf("%w: url is not valid", ErrValidation)
13	}
14
15	// Parse accepts "hello" as a valid relative URL, so check the parts we need.
16	if u.Scheme != "http" && u.Scheme != "https" {
17		return "", fmt.Errorf("%w: url must start with http:// or https://", ErrValidation)
18	}
19	if u.Host == "" {
20		return "", fmt.Errorf("%w: url has no host", ErrValidation)
21	}
22
23	return u.String(), nil
24}

1package web
2
3import (
4	"encoding/json"
5	"errors"
6	"net/http"
7
8	"github.com/you/shortener/internal/model"
9	"github.com/you/shortener/internal/service"
10)
11
12type Handler struct{ svc *service.Service }
13
14func NewHandler(s *service.Service) *Handler { return &Handler{svc: s} }
15
16func (h *Handler) Routes(mux *http.ServeMux) {
17	mux.HandleFunc("POST /links", h.create)
18}
19
20func (h *Handler) create(w http.ResponseWriter, r *http.Request) {
21	var in struct {
22		URL string `json:"url"`
23	}
24
25	// Cap the body before reading it, or a huge request can take the server down.
26	dec := json.NewDecoder(http.MaxBytesReader(w, r.Body, 1<<20))
27	if err := dec.Decode(&in); err != nil {
28		Error(w, 400, "invalid json")   // no package name: respond.go is package web too
29		return                          // always return after writing an error
30	}
31
32	l, err := h.svc.Shorten(r.Context(), in.URL)
33	if err != nil {
34		if errors.Is(err, model.ErrValidation) {
35			Error(w, 422, err.Error())
36			return
37		}
38		Error(w, 500, "could not shorten that url")
39		return
40	}
41
42	JSON(w, 201, l)
43}

1st := store.NewMemory()
2svc := service.New(st)
3h := web.NewHandler(svc)
4
5mux := http.NewServeMux()
6h.Routes(mux)                      // built from the inside out: store, service, handler

1curl -s -X POST localhost:8080/links -d '{"url":"https://go.dev/doc/"}'
2# {"code":"kR7mQp","long_url":"https://go.dev/doc/", ...}
3
4curl -s -X POST localhost:8080/links -d '{"url":"hello"}'
5# {"error":"invalid input: url must start with http:// or https://"}
6
7curl -s -X POST localhost:8080/links -d 'not json'
8# {"error":"invalid json"}