refactor: extract API handlers into internal packages
Move HTTP handler logic out of main into internal api and server packages, slimming main to a thin entrypoint. Bundles bug fixes: login nil-panic, empty-password validation, chirp sort ordering, duplicate-email 409, and restricting the file server to the assets directory.
This commit is contained in:
Stevan Freeborn
@@ -3,800 +3,28 @@ package main
|
||||
import (
|
||||
"context"
|
||||
"database/sql"
|
||||
"encoding/json"
|
||||
_ "embed"
|
||||
"errors"
|
||||
"fmt"
|
||||
"log"
|
||||
"net/http"
|
||||
"os"
|
||||
"os/signal"
|
||||
"slices"
|
||||
"strings"
|
||||
"sync/atomic"
|
||||
"syscall"
|
||||
"time"
|
||||
|
||||
"github.com/StevanFreeborn/chirpy/internal/auth"
|
||||
"github.com/StevanFreeborn/chirpy/internal/database"
|
||||
"github.com/google/uuid"
|
||||
"github.com/StevanFreeborn/chirpy/internal/server"
|
||||
"github.com/joho/godotenv"
|
||||
_ "github.com/lib/pq"
|
||||
)
|
||||
|
||||
type server struct {
|
||||
fileServerHits atomic.Int32
|
||||
database *database.Queries
|
||||
platform string
|
||||
jwtSecret []byte
|
||||
polkaKey string
|
||||
}
|
||||
|
||||
func writeJsonResponse(w http.ResponseWriter, statusCode int, response any) {
|
||||
if response == nil {
|
||||
w.WriteHeader(statusCode)
|
||||
return
|
||||
}
|
||||
|
||||
data, err := json.Marshal(response)
|
||||
|
||||
if err != nil {
|
||||
w.Header().Add("Content-Type", "application/json")
|
||||
w.WriteHeader(http.StatusInternalServerError)
|
||||
|
||||
err := apiError{
|
||||
Err: "Failed to encode JSON response",
|
||||
}
|
||||
|
||||
errData, _ := json.Marshal(err)
|
||||
|
||||
w.Write(errData)
|
||||
return
|
||||
}
|
||||
|
||||
w.Header().Add("Content-Type", "application/json")
|
||||
w.WriteHeader(statusCode)
|
||||
w.Write(data)
|
||||
}
|
||||
|
||||
func decodeJsonRequest[T any](r *http.Request) (*T, error) {
|
||||
defer r.Body.Close()
|
||||
var data *T
|
||||
decoder := json.NewDecoder(r.Body)
|
||||
err := decoder.Decode(&data)
|
||||
|
||||
if err != nil {
|
||||
return nil, apiError{
|
||||
Err: "Failed to deserialize request",
|
||||
}
|
||||
}
|
||||
|
||||
return data, err
|
||||
}
|
||||
|
||||
func (s *server) HandleFiles(prefix string) http.Handler {
|
||||
fileServer := http.StripPrefix(prefix, http.FileServer(http.Dir(".")))
|
||||
|
||||
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
||||
s.fileServerHits.Add(1)
|
||||
fileServer.ServeHTTP(w, r)
|
||||
})
|
||||
}
|
||||
|
||||
func (s *server) HandleHealthChecks(w http.ResponseWriter, r *http.Request) {
|
||||
w.Header().Add("Content-Type", "text/plain; charset=utf-8")
|
||||
w.WriteHeader(http.StatusOK)
|
||||
w.Write([]byte("OK"))
|
||||
}
|
||||
|
||||
func (s *server) HandleReset(w http.ResponseWriter, r *http.Request) {
|
||||
if s.platform != "dev" {
|
||||
w.WriteHeader(http.StatusForbidden)
|
||||
return
|
||||
}
|
||||
|
||||
s.fileServerHits.Store(0)
|
||||
|
||||
s.database.DeleteAllUsers(r.Context())
|
||||
|
||||
w.Header().Add("Content-Type", "text/plain; charset=utf-8")
|
||||
w.WriteHeader(http.StatusOK)
|
||||
w.Write([]byte("OK"))
|
||||
}
|
||||
|
||||
func (s *server) HandleMetrics(w http.ResponseWriter, r *http.Request) {
|
||||
hits := s.fileServerHits.Load()
|
||||
|
||||
w.Header().Add("Content-Type", "text/html; charset=utf-8")
|
||||
w.WriteHeader(http.StatusOK)
|
||||
|
||||
template := `
|
||||
<html>
|
||||
<body>
|
||||
<h1>Welcome, Chirpy Admin</h1>
|
||||
<p>Chirpy has been visited %d times!</p>
|
||||
</body>
|
||||
</html>
|
||||
`
|
||||
|
||||
fmt.Fprintf(w, template, hits)
|
||||
}
|
||||
|
||||
type apiError struct {
|
||||
Err string `json:"error"`
|
||||
}
|
||||
|
||||
func (e apiError) Error() string {
|
||||
return e.Err
|
||||
}
|
||||
|
||||
type createChirpRequest struct {
|
||||
Body string `json:"body"`
|
||||
UserId string `json:"user_id"`
|
||||
}
|
||||
|
||||
type chirpResponse struct {
|
||||
Id string `json:"id"`
|
||||
CreatedAt string `json:"created_at"`
|
||||
UpdatedAt string `json:"updated_at"`
|
||||
Body string `json:"body"`
|
||||
UserId string `json:"user_id"`
|
||||
}
|
||||
|
||||
func (s *server) HandleCreateChirp(w http.ResponseWriter, r *http.Request) {
|
||||
blacklist := []string{
|
||||
"kerfuffle",
|
||||
"sharbert",
|
||||
"fornax",
|
||||
}
|
||||
|
||||
bearerToken, err := auth.GetBearerToken(r.Header)
|
||||
|
||||
unauthorizedError := apiError{
|
||||
Err: "You are not authorized to perform this action",
|
||||
}
|
||||
|
||||
if err != nil {
|
||||
writeJsonResponse(w, http.StatusUnauthorized, unauthorizedError)
|
||||
return
|
||||
}
|
||||
|
||||
requestUserId, err := auth.ValidateJWT(bearerToken, s.jwtSecret)
|
||||
|
||||
if err != nil {
|
||||
writeJsonResponse(w, http.StatusUnauthorized, unauthorizedError)
|
||||
return
|
||||
}
|
||||
|
||||
createChirpRequest, err := decodeJsonRequest[createChirpRequest](r)
|
||||
|
||||
if err != nil {
|
||||
writeJsonResponse(w, http.StatusBadRequest, err)
|
||||
return
|
||||
}
|
||||
|
||||
if len(createChirpRequest.Body) > 140 {
|
||||
writeJsonResponse(w, http.StatusBadRequest, apiError{
|
||||
Err: "Chirp is too long",
|
||||
})
|
||||
return
|
||||
}
|
||||
|
||||
words := strings.Split(createChirpRequest.Body, " ")
|
||||
sanitized := []string{}
|
||||
|
||||
for _, word := range words {
|
||||
if slices.Contains(blacklist, strings.ToLower(word)) {
|
||||
sanitized = append(sanitized, "****")
|
||||
continue
|
||||
}
|
||||
|
||||
sanitized = append(sanitized, word)
|
||||
}
|
||||
|
||||
cleanedBody := strings.Join(sanitized, " ")
|
||||
|
||||
createChirpParams := database.CreateChirpParams{
|
||||
Body: cleanedBody,
|
||||
UserID: requestUserId,
|
||||
}
|
||||
|
||||
createdChirp, err := s.database.CreateChirp(r.Context(), createChirpParams)
|
||||
|
||||
if err != nil {
|
||||
writeJsonResponse(w, http.StatusInternalServerError, apiError{
|
||||
Err: "Failed to create chirp. 🤷🏻♂️",
|
||||
})
|
||||
return
|
||||
}
|
||||
|
||||
writeJsonResponse(w, http.StatusCreated, chirpResponse{
|
||||
Id: createdChirp.ID.String(),
|
||||
CreatedAt: createdChirp.CreatedAt.Format(time.RFC3339),
|
||||
UpdatedAt: createdChirp.UpdatedAt.Format(time.RFC3339),
|
||||
Body: createdChirp.Body,
|
||||
UserId: createdChirp.UserID.String(),
|
||||
})
|
||||
}
|
||||
|
||||
type createUserRequest struct {
|
||||
Email string `json:"email"`
|
||||
Password string `json:"password"`
|
||||
}
|
||||
|
||||
type createUserResponse struct {
|
||||
Id string `json:"id"`
|
||||
CreatedAt string `json:"created_at"`
|
||||
UpdatedAt string `json:"updated_at"`
|
||||
Email string `json:"email"`
|
||||
IsChirpyRed bool `json:"is_chirpy_red"`
|
||||
}
|
||||
|
||||
func (s *server) HandleCreateUser(w http.ResponseWriter, r *http.Request) {
|
||||
createUserRequest, err := decodeJsonRequest[createUserRequest](r)
|
||||
|
||||
if err != nil {
|
||||
writeJsonResponse(w, http.StatusBadRequest, err)
|
||||
return
|
||||
}
|
||||
|
||||
trimmedEmail := strings.TrimSpace(createUserRequest.Email)
|
||||
|
||||
if strings.TrimSpace(trimmedEmail) == "" {
|
||||
writeJsonResponse(w, http.StatusBadRequest, apiError{
|
||||
Err: "email is required. must be valid email address.",
|
||||
})
|
||||
return
|
||||
}
|
||||
|
||||
trimmedPassword := strings.TrimSpace(createUserRequest.Password)
|
||||
|
||||
if strings.TrimSpace(trimmedEmail) == "" {
|
||||
writeJsonResponse(w, http.StatusBadRequest, apiError{
|
||||
Err: "password is required. must be non-empty string.",
|
||||
})
|
||||
return
|
||||
}
|
||||
|
||||
hashed_password, err := auth.HashPassword(trimmedPassword)
|
||||
|
||||
createUserError := apiError{
|
||||
Err: "Uh oh we were unable to create a new user",
|
||||
}
|
||||
|
||||
if err != nil {
|
||||
writeJsonResponse(w, http.StatusInternalServerError, createUserError)
|
||||
return
|
||||
}
|
||||
|
||||
createUserParams := database.CreateUserParams{
|
||||
Email: trimmedEmail,
|
||||
HashedPassword: hashed_password,
|
||||
}
|
||||
|
||||
createdUser, err := s.database.CreateUser(r.Context(), createUserParams)
|
||||
|
||||
if err != nil {
|
||||
writeJsonResponse(w, http.StatusInternalServerError, createUserError)
|
||||
return
|
||||
}
|
||||
|
||||
writeJsonResponse(w, http.StatusCreated, createUserResponse{
|
||||
Id: createdUser.ID.String(),
|
||||
CreatedAt: createdUser.CreatedAt.Format(time.RFC3339),
|
||||
UpdatedAt: createdUser.UpdatedAt.Format(time.RFC3339),
|
||||
Email: createdUser.Email,
|
||||
IsChirpyRed: createdUser.IsChirpyRed,
|
||||
})
|
||||
}
|
||||
|
||||
const (
|
||||
Ascending = "asc"
|
||||
Descending = "desc"
|
||||
)
|
||||
|
||||
func (s *server) HandleGetChirps(w http.ResponseWriter, r *http.Request) {
|
||||
authorId := r.URL.Query().Get("author_id")
|
||||
sortDir := r.URL.Query().Get("sort")
|
||||
|
||||
hasAuthorId := strings.TrimSpace(authorId) != ""
|
||||
hasSort := strings.TrimSpace(sortDir) != ""
|
||||
|
||||
validAuthorId, err := uuid.Parse(authorId)
|
||||
|
||||
if hasAuthorId && err != nil {
|
||||
writeJsonResponse(w, http.StatusBadRequest, apiError{
|
||||
Err: "Author id must be a valid uuid",
|
||||
})
|
||||
return
|
||||
}
|
||||
|
||||
if hasSort && sortDir != Ascending && sortDir != Descending {
|
||||
writeJsonResponse(w, http.StatusBadRequest, apiError{
|
||||
Err: fmt.Sprintf("Sort direction must be either '%s' or '%s'", Ascending, Descending),
|
||||
})
|
||||
return
|
||||
}
|
||||
|
||||
if !hasSort {
|
||||
sortDir = "asc"
|
||||
}
|
||||
|
||||
var existingChirps []database.Chirp
|
||||
|
||||
if hasAuthorId {
|
||||
existingChirps, err = s.database.GetChirpsByAuthor(r.Context(), validAuthorId)
|
||||
} else {
|
||||
existingChirps, err = s.database.GetAllChirps(r.Context())
|
||||
}
|
||||
|
||||
slices.SortFunc(existingChirps, func(a, b database.Chirp) int {
|
||||
if sortDir == Descending {
|
||||
return b.CreatedAt.Compare(a.CreatedAt)
|
||||
}
|
||||
|
||||
return a.CreatedAt.Compare(b.CreatedAt)
|
||||
})
|
||||
|
||||
if err != nil {
|
||||
writeJsonResponse(w, http.StatusInternalServerError, apiError{
|
||||
Err: "Unable to retrieve chirps",
|
||||
})
|
||||
return
|
||||
}
|
||||
|
||||
chirps := []chirpResponse{}
|
||||
|
||||
for _, c := range existingChirps {
|
||||
chirps = append(chirps, chirpResponse{
|
||||
Id: c.ID.String(),
|
||||
CreatedAt: c.CreatedAt.Format(time.RFC3339),
|
||||
UpdatedAt: c.UpdatedAt.Format(time.RFC3339),
|
||||
Body: c.Body,
|
||||
UserId: c.UserID.String(),
|
||||
})
|
||||
}
|
||||
|
||||
writeJsonResponse(w, http.StatusOK, chirps)
|
||||
}
|
||||
|
||||
func (s *server) HandleGetChirp(w http.ResponseWriter, r *http.Request) {
|
||||
chirpId := r.PathValue("id")
|
||||
validChirpId, err := uuid.Parse(chirpId)
|
||||
|
||||
if err != nil {
|
||||
writeJsonResponse(w, http.StatusBadRequest, apiError{
|
||||
Err: "Chirp id is not valid. id must be valid UUID.",
|
||||
})
|
||||
return
|
||||
}
|
||||
|
||||
existingChirp, err := s.database.GetChirpById(r.Context(), validChirpId)
|
||||
|
||||
if err != nil {
|
||||
writeJsonResponse(w, http.StatusNotFound, apiError{
|
||||
Err: "No chirp with given id found.",
|
||||
})
|
||||
return
|
||||
}
|
||||
|
||||
writeJsonResponse(w, http.StatusOK, chirpResponse{
|
||||
Id: existingChirp.ID.String(),
|
||||
CreatedAt: existingChirp.CreatedAt.Format(time.RFC3339),
|
||||
UpdatedAt: existingChirp.UpdatedAt.Format(time.RFC3339),
|
||||
Body: existingChirp.Body,
|
||||
UserId: existingChirp.UserID.String(),
|
||||
})
|
||||
}
|
||||
|
||||
type loginRequest struct {
|
||||
Email string `json:"email"`
|
||||
Password string `json:"password"`
|
||||
}
|
||||
|
||||
func (r *loginRequest) Validate() error {
|
||||
if strings.TrimSpace(r.Email) == "" || strings.TrimSpace(r.Password) == "" {
|
||||
return apiError{
|
||||
Err: "Email and password must be non-empty string",
|
||||
}
|
||||
}
|
||||
|
||||
return nil
|
||||
}
|
||||
|
||||
type loginResponse struct {
|
||||
Id string `json:"id"`
|
||||
CreatedAt string `json:"created_at"`
|
||||
UpdatedAt string `json:"updated_at"`
|
||||
Email string `json:"email"`
|
||||
IsChirpyRed bool `json:"is_chirpy_red"`
|
||||
Token string `json:"token"`
|
||||
RefreshToken string `json:"refresh_token"`
|
||||
}
|
||||
|
||||
func (s *server) HandleLogin(w http.ResponseWriter, r *http.Request) {
|
||||
loginRequest, err := decodeJsonRequest[loginRequest](r)
|
||||
|
||||
err = loginRequest.Validate()
|
||||
|
||||
if err != nil {
|
||||
writeJsonResponse(w, http.StatusBadRequest, err)
|
||||
return
|
||||
}
|
||||
|
||||
existingUser, err := s.database.GetUserByEmail(r.Context(), loginRequest.Email)
|
||||
|
||||
invalidLoginError := apiError{
|
||||
Err: "Invalid login request",
|
||||
}
|
||||
|
||||
if err != nil {
|
||||
writeJsonResponse(w, http.StatusUnauthorized, invalidLoginError)
|
||||
return
|
||||
}
|
||||
|
||||
isCorrectPassword, err := auth.CheckPasswordHash(loginRequest.Password, existingUser.HashedPassword)
|
||||
|
||||
if err != nil || isCorrectPassword == false {
|
||||
writeJsonResponse(w, http.StatusUnauthorized, invalidLoginError)
|
||||
return
|
||||
}
|
||||
|
||||
SECONDS_PER_HOUR := 3600
|
||||
expiresInDuration := time.Duration(SECONDS_PER_HOUR) * time.Second
|
||||
|
||||
accessToken, err := auth.MakeJWT(existingUser.ID, s.jwtSecret, expiresInDuration)
|
||||
|
||||
loginFailedError := apiError{
|
||||
Err: "Login failed",
|
||||
}
|
||||
|
||||
if err != nil {
|
||||
writeJsonResponse(w, http.StatusInternalServerError, loginFailedError)
|
||||
return
|
||||
}
|
||||
|
||||
createRefreshTokenParams := database.CreateRefreshTokenParams{
|
||||
Token: auth.MakeRefreshToken(),
|
||||
ExpiresAt: time.Now().Add(60 * 24 * time.Hour),
|
||||
RevokedAt: sql.NullTime{
|
||||
Valid: false,
|
||||
},
|
||||
UserID: existingUser.ID,
|
||||
}
|
||||
|
||||
createdRefreshToken, err := s.database.CreateRefreshToken(r.Context(), createRefreshTokenParams)
|
||||
|
||||
if err != nil {
|
||||
writeJsonResponse(w, http.StatusInternalServerError, loginFailedError)
|
||||
return
|
||||
}
|
||||
|
||||
writeJsonResponse(w, http.StatusOK, loginResponse{
|
||||
Id: existingUser.ID.String(),
|
||||
CreatedAt: existingUser.CreatedAt.Format(time.RFC3339),
|
||||
UpdatedAt: existingUser.UpdatedAt.Format(time.RFC3339),
|
||||
Email: existingUser.Email,
|
||||
IsChirpyRed: existingUser.IsChirpyRed,
|
||||
Token: accessToken,
|
||||
RefreshToken: createdRefreshToken.Token,
|
||||
})
|
||||
}
|
||||
|
||||
type refreshTokenResponse struct {
|
||||
Token string `json:"token"`
|
||||
}
|
||||
|
||||
func (s *server) HandleRefresh(w http.ResponseWriter, r *http.Request) {
|
||||
refreshToken, err := auth.GetBearerToken(r.Header)
|
||||
|
||||
unauthorizedError := apiError{
|
||||
Err: "Unable to refresh token",
|
||||
}
|
||||
|
||||
if err != nil {
|
||||
writeJsonResponse(w, http.StatusUnauthorized, unauthorizedError)
|
||||
return
|
||||
}
|
||||
|
||||
existingRefreshToken, err := s.database.GetRefreshTokenByToken(r.Context(), refreshToken)
|
||||
|
||||
if err != nil {
|
||||
writeJsonResponse(w, http.StatusUnauthorized, unauthorizedError)
|
||||
return
|
||||
}
|
||||
|
||||
if existingRefreshToken.ExpiresAt.Before(time.Now()) || existingRefreshToken.RevokedAt.Valid {
|
||||
writeJsonResponse(w, http.StatusUnauthorized, unauthorizedError)
|
||||
return
|
||||
}
|
||||
|
||||
SECONDS_PER_HOUR := 3600
|
||||
expiresInDuration := time.Duration(SECONDS_PER_HOUR) * time.Second
|
||||
|
||||
accessToken, err := auth.MakeJWT(existingRefreshToken.UserID, s.jwtSecret, expiresInDuration)
|
||||
|
||||
if err != nil {
|
||||
writeJsonResponse(w, http.StatusInternalServerError, apiError{
|
||||
Err: "Failed to refresh token",
|
||||
})
|
||||
return
|
||||
}
|
||||
|
||||
// TODO: We should rotate the refresh token
|
||||
|
||||
writeJsonResponse(w, http.StatusOK, refreshTokenResponse{
|
||||
Token: accessToken,
|
||||
})
|
||||
}
|
||||
|
||||
func (s *server) HandleRevoke(w http.ResponseWriter, r *http.Request) {
|
||||
refreshToken, err := auth.GetBearerToken(r.Header)
|
||||
|
||||
if err != nil {
|
||||
writeJsonResponse(w, http.StatusBadRequest, apiError{
|
||||
Err: "No refresh token present in request",
|
||||
})
|
||||
return
|
||||
}
|
||||
|
||||
existingRefreshToken, err := s.database.GetRefreshTokenByToken(r.Context(), refreshToken)
|
||||
|
||||
if err != nil {
|
||||
writeJsonResponse(w, http.StatusNotFound, apiError{
|
||||
Err: "Unable to revoke token",
|
||||
})
|
||||
return
|
||||
}
|
||||
|
||||
err = s.database.RevokeRefreshToken(r.Context(), existingRefreshToken.Token)
|
||||
|
||||
if err != nil {
|
||||
writeJsonResponse(w, http.StatusInternalServerError, apiError{
|
||||
Err: "Unable to revoke token",
|
||||
})
|
||||
return
|
||||
}
|
||||
|
||||
writeJsonResponse(w, http.StatusNoContent, nil)
|
||||
}
|
||||
|
||||
type updateUserRequest struct {
|
||||
Email string `json:"email"`
|
||||
Password string `json:"password"`
|
||||
}
|
||||
|
||||
type updateUserResponse struct {
|
||||
Id string `json:"id"`
|
||||
CreatedAt string `json:"created_at"`
|
||||
UpdatedAt string `json:"updated_at"`
|
||||
Email string `json:"email"`
|
||||
IsChirpyRed bool `json:"is_chirpy_red"`
|
||||
}
|
||||
|
||||
func (r *updateUserRequest) Validate() error {
|
||||
if strings.TrimSpace(r.Email) == "" || strings.TrimSpace(r.Password) == "" {
|
||||
return apiError{
|
||||
Err: "Email and password must be non-empty string",
|
||||
}
|
||||
}
|
||||
|
||||
return nil
|
||||
}
|
||||
|
||||
func (s *server) HandleUpdateUser(w http.ResponseWriter, r *http.Request) {
|
||||
accessToken, err := auth.GetBearerToken(r.Header)
|
||||
|
||||
if err != nil {
|
||||
writeJsonResponse(w, http.StatusUnauthorized, apiError{
|
||||
Err: "You are not authorized to perform this action",
|
||||
})
|
||||
return
|
||||
}
|
||||
|
||||
requestUserId, err := auth.ValidateJWT(accessToken, s.jwtSecret)
|
||||
|
||||
if err != nil {
|
||||
writeJsonResponse(w, http.StatusUnauthorized, apiError{
|
||||
Err: "You are not authorized to perform this action",
|
||||
})
|
||||
return
|
||||
}
|
||||
|
||||
updateUserRequest, err := decodeJsonRequest[updateUserRequest](r)
|
||||
|
||||
if err != nil {
|
||||
writeJsonResponse(w, http.StatusBadRequest, err)
|
||||
return
|
||||
}
|
||||
|
||||
err = updateUserRequest.Validate()
|
||||
|
||||
if err != nil {
|
||||
writeJsonResponse(w, http.StatusBadRequest, err)
|
||||
return
|
||||
}
|
||||
|
||||
updatedHashedPassword, err := auth.HashPassword(updateUserRequest.Password)
|
||||
|
||||
updateError := apiError{
|
||||
Err: "Unable to perform update",
|
||||
}
|
||||
|
||||
if err != nil {
|
||||
writeJsonResponse(w, http.StatusInternalServerError, updateError)
|
||||
return
|
||||
}
|
||||
|
||||
updateUserParams := database.UpdateUserParams{
|
||||
ID: requestUserId,
|
||||
Email: updateUserRequest.Email,
|
||||
HashedPassword: updatedHashedPassword,
|
||||
}
|
||||
|
||||
updatedUser, err := s.database.UpdateUser(r.Context(), updateUserParams)
|
||||
|
||||
if err != nil {
|
||||
writeJsonResponse(w, http.StatusInternalServerError, updateError)
|
||||
return
|
||||
}
|
||||
|
||||
writeJsonResponse(w, http.StatusOK, updateUserResponse{
|
||||
Id: updatedUser.ID.String(),
|
||||
CreatedAt: updatedUser.CreatedAt.Format(time.RFC3339),
|
||||
UpdatedAt: updatedUser.UpdatedAt.Format(time.RFC3339),
|
||||
Email: updatedUser.Email,
|
||||
IsChirpyRed: updatedUser.IsChirpyRed,
|
||||
})
|
||||
}
|
||||
|
||||
func (s *server) HandleDeleteChirp(w http.ResponseWriter, r *http.Request) {
|
||||
accessToken, err := auth.GetBearerToken(r.Header)
|
||||
|
||||
unauthorizedError := apiError{
|
||||
Err: "You are not authorized to perform this action",
|
||||
}
|
||||
|
||||
if err != nil {
|
||||
writeJsonResponse(w, http.StatusUnauthorized, unauthorizedError)
|
||||
return
|
||||
}
|
||||
|
||||
requestUserId, err := auth.ValidateJWT(accessToken, s.jwtSecret)
|
||||
|
||||
if err != nil {
|
||||
writeJsonResponse(w, http.StatusUnauthorized, unauthorizedError)
|
||||
return
|
||||
}
|
||||
|
||||
chirpId := r.PathValue("id")
|
||||
validChirpId, err := uuid.Parse(chirpId)
|
||||
|
||||
invalidChirpIdError := apiError{
|
||||
Err: "Chirp id must be a valid uuid for an existing chirp",
|
||||
}
|
||||
|
||||
if err != nil {
|
||||
writeJsonResponse(w, http.StatusBadRequest, invalidChirpIdError)
|
||||
return
|
||||
}
|
||||
|
||||
existingChirp, err := s.database.GetChirpById(r.Context(), validChirpId)
|
||||
|
||||
if err != nil {
|
||||
writeJsonResponse(w, http.StatusNotFound, invalidChirpIdError)
|
||||
return
|
||||
}
|
||||
|
||||
if existingChirp.UserID != requestUserId {
|
||||
writeJsonResponse(w, http.StatusForbidden, apiError{
|
||||
Err: "You can not delete a chirp that does not belong to you",
|
||||
})
|
||||
return
|
||||
}
|
||||
|
||||
err = s.database.DeleteChirpById(r.Context(), existingChirp.ID)
|
||||
|
||||
if err != nil {
|
||||
writeJsonResponse(w, http.StatusInternalServerError, apiError{
|
||||
Err: "Yo bro we couldn't delete that shit",
|
||||
})
|
||||
return
|
||||
}
|
||||
|
||||
writeJsonResponse(w, http.StatusNoContent, nil)
|
||||
}
|
||||
|
||||
type userUpgradeData struct {
|
||||
UserId string `json:"user_id"`
|
||||
}
|
||||
|
||||
type webhookEvent struct {
|
||||
Event string `json:"event"`
|
||||
Data any `json:"-"`
|
||||
}
|
||||
|
||||
func (p *webhookEvent) UnmarshalJSON(b []byte) error {
|
||||
type Alias webhookEvent
|
||||
|
||||
aux := &struct {
|
||||
*Alias
|
||||
RawData json.RawMessage `json:"data"`
|
||||
}{
|
||||
Alias: (*Alias)(p),
|
||||
}
|
||||
|
||||
if err := json.Unmarshal(b, aux); err != nil {
|
||||
return err
|
||||
}
|
||||
|
||||
switch p.Event {
|
||||
case "user.upgraded":
|
||||
var data userUpgradeData
|
||||
|
||||
if err := json.Unmarshal(aux.RawData, &data); err != nil {
|
||||
return err
|
||||
}
|
||||
|
||||
p.Data = data
|
||||
default:
|
||||
}
|
||||
|
||||
return nil
|
||||
}
|
||||
|
||||
func (s *server) HandleWebhooks(w http.ResponseWriter, r *http.Request) {
|
||||
apiKey, err := auth.GetAPIKey(r.Header)
|
||||
|
||||
unauthorizedError := apiError{
|
||||
Err: "You are not authorized to perform this action",
|
||||
}
|
||||
|
||||
if err != nil || apiKey != s.polkaKey {
|
||||
writeJsonResponse(w, http.StatusUnauthorized, unauthorizedError)
|
||||
return
|
||||
}
|
||||
|
||||
event, err := decodeJsonRequest[webhookEvent](r)
|
||||
|
||||
if err != nil {
|
||||
writeJsonResponse(w, http.StatusInternalServerError, apiError{
|
||||
Err: "Unable to deserialize webhook event",
|
||||
})
|
||||
return
|
||||
}
|
||||
|
||||
switch v := event.Data.(type) {
|
||||
case userUpgradeData:
|
||||
validUserId, err := uuid.Parse(v.UserId)
|
||||
|
||||
userNotFoundError := apiError{
|
||||
Err: "Unable to upgrade user",
|
||||
}
|
||||
|
||||
if err != nil {
|
||||
writeJsonResponse(w, http.StatusNotFound, userNotFoundError)
|
||||
return
|
||||
}
|
||||
|
||||
_, err = s.database.UpgradeUser(r.Context(), validUserId)
|
||||
|
||||
if err != nil {
|
||||
writeJsonResponse(w, http.StatusNotFound, userNotFoundError)
|
||||
return
|
||||
}
|
||||
|
||||
writeJsonResponse(w, http.StatusNoContent, nil)
|
||||
default:
|
||||
writeJsonResponse(w, http.StatusNoContent, nil)
|
||||
}
|
||||
}
|
||||
//go:embed index.html
|
||||
var indexHTML []byte
|
||||
|
||||
func main() {
|
||||
err := godotenv.Load()
|
||||
|
||||
if err != nil {
|
||||
log.Fatalf("Failed to load environment variables")
|
||||
os.Exit(1)
|
||||
if err := godotenv.Load(); err != nil {
|
||||
log.Fatal("Failed to load environment variables")
|
||||
}
|
||||
|
||||
dbURL := os.Getenv("DB_URL")
|
||||
@@ -805,64 +33,36 @@ func main() {
|
||||
polkaKey := os.Getenv("POLKA_KEY")
|
||||
|
||||
if strings.TrimSpace(jwtSecret) == "" {
|
||||
log.Fatalf("Failed to retrieve JWT_SECRET")
|
||||
os.Exit(1)
|
||||
log.Fatal("Failed to retrieve JWT_SECRET")
|
||||
}
|
||||
|
||||
if strings.TrimSpace(polkaKey) == "" {
|
||||
log.Fatalf("Failed to retrieve POLKA_KEY")
|
||||
os.Exit(1)
|
||||
log.Fatal("Failed to retrieve POLKA_KEY")
|
||||
}
|
||||
|
||||
db, err := sql.Open("postgres", dbURL)
|
||||
|
||||
if err != nil {
|
||||
log.Fatalf("Failed to connect to database: %v", err)
|
||||
os.Exit(1)
|
||||
}
|
||||
|
||||
server := &server{
|
||||
database: database.New(db),
|
||||
platform: platform,
|
||||
jwtSecret: []byte(jwtSecret),
|
||||
polkaKey: polkaKey,
|
||||
if err := db.Ping(); err != nil {
|
||||
log.Fatalf("Failed to ping database: %v", err)
|
||||
}
|
||||
|
||||
mux := http.NewServeMux()
|
||||
|
||||
appRoot := "/app/"
|
||||
|
||||
mux.Handle(appRoot, server.HandleFiles(appRoot))
|
||||
mux.HandleFunc("GET /admin/metrics", server.HandleMetrics)
|
||||
mux.HandleFunc("POST /admin/reset", server.HandleReset)
|
||||
|
||||
mux.HandleFunc("GET /api/healthz", server.HandleHealthChecks)
|
||||
|
||||
mux.HandleFunc("POST /api/login", server.HandleLogin)
|
||||
mux.HandleFunc("POST /api/refresh", server.HandleRefresh)
|
||||
mux.HandleFunc("POST /api/revoke", server.HandleRevoke)
|
||||
mux.HandleFunc("POST /api/users", server.HandleCreateUser)
|
||||
mux.HandleFunc("PUT /api/users", server.HandleUpdateUser)
|
||||
mux.HandleFunc("POST /api/polka/webhooks", server.HandleWebhooks)
|
||||
|
||||
mux.HandleFunc("GET /api/chirps", server.HandleGetChirps)
|
||||
mux.HandleFunc("GET /api/chirps/{id}", server.HandleGetChirp)
|
||||
mux.HandleFunc("POST /api/chirps", server.HandleCreateChirp)
|
||||
mux.HandleFunc("DELETE /api/chirps/{id}", server.HandleDeleteChirp)
|
||||
srv := server.New(database.New(db), platform, []byte(jwtSecret), polkaKey, indexHTML)
|
||||
|
||||
port := ":8080"
|
||||
|
||||
httpServer := http.Server{
|
||||
Handler: mux,
|
||||
Handler: srv.Handler(),
|
||||
Addr: port,
|
||||
}
|
||||
|
||||
go func() {
|
||||
log.Printf("Server started and listening on %s\n", port)
|
||||
|
||||
err := httpServer.ListenAndServe()
|
||||
|
||||
if !errors.Is(err, http.ErrServerClosed) {
|
||||
if err := httpServer.ListenAndServe(); !errors.Is(err, http.ErrServerClosed) {
|
||||
log.Fatalf("HTTP Server error: %v", err)
|
||||
}
|
||||
|
||||
@@ -874,7 +74,6 @@ func main() {
|
||||
<-sigChan
|
||||
|
||||
shutdownCtx, shutdownRelease := context.WithTimeout(context.Background(), 10*time.Second)
|
||||
|
||||
defer shutdownRelease()
|
||||
|
||||
if err := httpServer.Shutdown(shutdownCtx); err != nil {
|
||||
|
||||
Reference in New Issue
Block a user