REST API design and JSON handlers

func writeJSON(w http.ResponseWriter, status int, v any) {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(status)
	if err := json.NewEncoder(w).Encode(v); err != nil {
		slog.Error("write json", "err", err)
	}
}

func writeError(w http.ResponseWriter, status int, msg string) {
	writeJSON(w, status, map[string]string{"error": msg})
}

type Expense struct {
	ID       int64     `json:"id"`
	Title    string    `json:"title"`
	Paise    int64     `json:"amount_paise"`
	Category string    `json:"category"`
	Created  time.Time `json:"created_at"`
}

var ErrNotFound = errors.New("not found")

type Store interface {
	Create(ctx context.Context, e Expense) (Expense, error)
	Get(ctx context.Context, id int64) (Expense, error)
	List(ctx context.Context, limit, offset int) ([]Expense, error)
}

type API struct{ store Store }

type createReq struct {
	Title    string `json:"title"`
	Paise    int64  `json:"amount_paise"`
	Category string `json:"category"`
}

func (r createReq) validate() error {
	if strings.TrimSpace(r.Title) == "" {
		return errors.New("title is required")
	}
	if r.Paise <= 0 {
		return errors.New("amount_paise must be positive")
	}
	return nil
}

func (a *API) createExpense(w http.ResponseWriter, r *http.Request) {
	var in createReq
	dec := json.NewDecoder(http.MaxBytesReader(w, r.Body, 1<<20))
	dec.DisallowUnknownFields()
	if err := dec.Decode(&in); err != nil {
		writeError(w, http.StatusBadRequest, "invalid JSON body")
		return
	}
	if err := in.validate(); err != nil {
		writeError(w, http.StatusUnprocessableEntity, err.Error())
		return
	}
	e, err := a.store.Create(r.Context(), Expense{Title: in.Title, Paise: in.Paise, Category: in.Category})
	if err != nil {
		slog.Error("create expense", "err", err)
		writeError(w, http.StatusInternalServerError, "could not save expense")
		return
	}
	w.Header().Set("Location", fmt.Sprintf("/v1/expenses/%d", e.ID))
	writeJSON(w, http.StatusCreated, e)
}

func (a *API) getExpense(w http.ResponseWriter, r *http.Request) {
	id, err := strconv.ParseInt(r.PathValue("id"), 10, 64)
	if err != nil {
		writeError(w, http.StatusBadRequest, "id must be a number")
		return
	}
	e, err := a.store.Get(r.Context(), id)
	if errors.Is(err, ErrNotFound) {
		writeError(w, http.StatusNotFound, "expense not found")
		return
	}
	if err != nil {
		slog.Error("get expense", "id", id, "err", err)
		writeError(w, http.StatusInternalServerError, "internal error")
		return
	}
	writeJSON(w, http.StatusOK, e)
}

func (a *API) routes() http.Handler {
	mux := http.NewServeMux()
	mux.HandleFunc("POST /v1/expenses", a.createExpense)
	mux.HandleFunc("GET /v1/expenses/{id}", a.getExpense)
	return mux
}

func TestCreateExpense(t *testing.T) {
	api := &API{store: newMemStore()}
	body := strings.NewReader(`{"title":"Lunch","amount_paise":-5}`)
	req := httptest.NewRequest(http.MethodPost, "/v1/expenses", body)
	rec := httptest.NewRecorder()

	api.routes().ServeHTTP(rec, req)

	if rec.Code != http.StatusUnprocessableEntity {
		t.Fatalf("status = %d; want 422", rec.Code)
	}
}