improve route handlers

Makefile

@@ -22,6 +22,8 @@ clean:
 test:
 	go test -v ./...
 
-.PHONY: curl
+.PHONY: curl curl-bad
 curl:
 	curl -v --data-binary @go.mod localhost:8080/api/ | xargs -I {} curl localhost:8080{}
+curl-bad:
+	curl -v localhost:8080/api/57c04c70-dd58-11ee-98fc-ebbaf68907f4/8bc419a2de0ccf0b165cd978f8894b77403a2f06019916af0bf48bcade88f518

api/api.go

@@ -2,10 +2,14 @@ package api
 
 import (
 	"database/sql"
+	"fmt"
 	"log"
 	"net/http"
 	"net/url"
+	"path"
+	"strings"
 
+	"github.com/Ajnasz/sekret.link/api/middlewares"
 	"github.com/Ajnasz/sekret.link/internal/api"
 	"github.com/Ajnasz/sekret.link/internal/models"
 	"github.com/Ajnasz/sekret.link/internal/parsers"
@@ -94,17 +98,63 @@ func (s SecretHandler) Options(w http.ResponseWriter, r *http.Request) {
 	// Your OPTIONS method logic goes here
 	w.WriteHeader(http.StatusOK)
 }
-func (s SecretHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
-	switch r.Method {
-	case http.MethodPost:
-		s.Post(w, r)
-	case http.MethodGet:
-		s.Get(w, r)
-	case http.MethodDelete:
-		s.Delete(w, r)
-	case http.MethodOptions:
-		s.Options(w, r)
-	default:
-		http.Error(w, "Not found", http.StatusNotFound)
+
+// NotFound handler
+func (s SecretHandler) NotFound(w http.ResponseWriter, r *http.Request) {
+	http.Error(w, "Not found", http.StatusNotFound)
+}
+
+func clearApiRoot(apiRoot string) string {
+	apiRoot = path.Clean(path.Join("/", apiRoot))
+
+	if strings.HasSuffix(apiRoot, "/") {
+		return apiRoot
 	}
+
+	return apiRoot + "/"
+}
+
+func (s SecretHandler) RegisterHandlers(mux *http.ServeMux, apiRoot string) {
+	mux.Handle(
+		fmt.Sprintf("GET %s", path.Join("/", apiRoot, "{uuid}", "{key}")),
+		http.StripPrefix(
+			apiRoot,
+			middlewares.SetupLogging(
+				middlewares.SetupHeaders(http.HandlerFunc(s.Get)),
+			),
+		),
+	)
+
+	mux.Handle(
+		fmt.Sprintf("POST %s", clearApiRoot(apiRoot)),
+		http.StripPrefix(
+			path.Join("/", apiRoot),
+			middlewares.SetupLogging(
+				middlewares.SetupHeaders(http.HandlerFunc(s.Post)),
+			),
+		),
+	)
+
+	mux.Handle(
+		fmt.Sprintf("DELETE %s", path.Join("/", apiRoot, "{uuid}", "{key}", "{deleteKey}")),
+		http.StripPrefix(
+			apiRoot,
+			middlewares.SetupLogging(
+				middlewares.SetupHeaders(http.HandlerFunc(s.Delete)),
+			),
+		),
+	)
+
+	mux.Handle(
+		fmt.Sprintf("OPTIONS %s", clearApiRoot(apiRoot)),
+		http.StripPrefix(
+			apiRoot,
+			middlewares.SetupLogging(
+				middlewares.SetupHeaders(http.HandlerFunc(s.Options)),
+			),
+		),
+	)
+
+	mux.Handle("/", middlewares.SetupLogging(middlewares.SetupHeaders(http.HandlerFunc(s.NotFound))))
+
 }

api/api_test.go

@@ -59,7 +59,6 @@ func TestCreateEntry(t *testing.T) {
 
 		resp := w.Result()
 		body, err := io.ReadAll(resp.Body)
-		fmt.Println("BODYDYDYDDY", body, err)
 
 		if err != nil {
 			t.Fatal(err)
@@ -370,9 +369,18 @@ func TestGetEntry(t *testing.T) {
 
 			req := httptest.NewRequest(http.MethodGet, fmt.Sprintf("http://example.com/%s/%s", testCase.UUID, hex.EncodeToString(rsakey)), nil)
 			w := httptest.NewRecorder()
-			NewSecretHandler(NewHandlerConfig(connection, connection.GetDB())).ServeHTTP(w, req)
+
+			mux := http.NewServeMux()
+			secretHandler := NewSecretHandler(NewHandlerConfig(connection, connection.GetDB()))
+			secretHandler.RegisterHandlers(mux, "")
+
+			mux.ServeHTTP(w, req)
 
 			resp := w.Result()
+
+			if resp.StatusCode != http.StatusOK {
+				t.Fatalf("expected statuscode %d got %d", http.StatusOK, resp.StatusCode)
+			}
 			body, _ := io.ReadAll(resp.Body)
 
 			actual := string(body)
@@ -420,7 +428,11 @@ func TestGetEntryJSON(t *testing.T) {
 	req := httptest.NewRequest("GET", fmt.Sprintf("http://example.com/%s/%s", testCase.UUID, hex.EncodeToString(rsakey)), nil)
 	req.Header.Add("Accept", "application/json")
 	w := httptest.NewRecorder()
-	NewSecretHandler(NewHandlerConfig(connection, connection.GetDB())).ServeHTTP(w, req)
+
+	mux := http.NewServeMux()
+	secretHandler := NewSecretHandler(NewHandlerConfig(connection, connection.GetDB()))
+	secretHandler.RegisterHandlers(mux, "")
+	mux.ServeHTTP(w, req)
 
 	resp := w.Result()
 	if resp.StatusCode != 200 {
@@ -457,12 +469,19 @@ func TestSetAndGetEntry(t *testing.T) {
 		connection.Close()
 	})
 
-	req := httptest.NewRequest("POST", "http://example.com", bytes.NewReader([]byte(testCase)))
+	req := httptest.NewRequest("POST", "http://example.com/", bytes.NewReader([]byte(testCase)))
 	w := httptest.NewRecorder()
 
-	NewSecretHandler(NewHandlerConfig(connection, connection.GetDB())).ServeHTTP(w, req)
+	mux := http.NewServeMux()
+	secretHandler := NewSecretHandler(NewHandlerConfig(connection, connection.GetDB()))
+	secretHandler.RegisterHandlers(mux, "")
+	mux.ServeHTTP(w, req)
 
 	resp := w.Result()
+
+	if resp.StatusCode != 200 {
+		t.Fatalf("expected statuscode %d got %d", 200, resp.StatusCode)
+	}
 	body, _ := io.ReadAll(resp.Body)
 
 	responseURL := string(body)
@@ -474,7 +493,8 @@ func TestSetAndGetEntry(t *testing.T) {
 
 	req = httptest.NewRequest("GET", fmt.Sprintf("http://example.com/%s/%s", savedUUID, keyString), nil)
 	w = httptest.NewRecorder()
-	NewSecretHandler(NewHandlerConfig(connection, connection.GetDB())).ServeHTTP(w, req)
+
+	mux.ServeHTTP(w, req)
 
 	resp = w.Result()
 	body, _ = io.ReadAll(resp.Body)
@@ -694,10 +714,14 @@ func FuzzSetAndGetEntry(f *testing.F) {
 			t.Log("empty")
 			return
 		}
-		req := httptest.NewRequest("POST", "http://example.com", bytes.NewReader([]byte(testCase)))
-		w := httptest.NewRecorder()
 
-		NewSecretHandler(NewHandlerConfig(connection, connection.GetDB())).ServeHTTP(w, req)
+		mux := http.NewServeMux()
+		secretHandler := NewSecretHandler(NewHandlerConfig(connection, connection.GetDB()))
+		secretHandler.RegisterHandlers(mux, "")
+
+		req := httptest.NewRequest("POST", "http://example.com/", bytes.NewReader([]byte(testCase)))
+		w := httptest.NewRecorder()
+		mux.ServeHTTP(w, req)
 
 		resp := w.Result()
 		body, _ := io.ReadAll(resp.Body)
@@ -711,7 +735,7 @@ func FuzzSetAndGetEntry(f *testing.F) {
 
 		req = httptest.NewRequest("GET", fmt.Sprintf("http://example.com/%s/%s", savedUUID, keyString), nil)
 		w = httptest.NewRecorder()
-		NewSecretHandler(NewHandlerConfig(connection, connection.GetDB())).ServeHTTP(w, req)
+		mux.ServeHTTP(w, req)
 
 		resp = w.Result()
 		body, _ = io.ReadAll(resp.Body)

api/middlewares/middlewares.go

@@ -8,7 +8,11 @@ import (
 
 func SetupLogging(h http.Handler) http.Handler {
 	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		log.Println(fmt.Sprintf("%s: %s", r.Method, r.URL.Path))
+		if r.Method == http.MethodGet {
+			log.Println(fmt.Sprintf("%s: %s", r.Method, "/***"))
+		} else {
+			log.Println(fmt.Sprintf("%s: %s", r.Method, r.URL.Path))
+		}
 		h.ServeHTTP(w, r)
 	})
 }

cmd/sekret.link/main.go

@@ -15,7 +15,6 @@ import (
 	"time"
 
 	"github.com/Ajnasz/sekret.link/api"
-	"github.com/Ajnasz/sekret.link/api/middlewares"
 	"github.com/Ajnasz/sekret.link/config"
 	"github.com/Ajnasz/sekret.link/storage"
 	"github.com/Ajnasz/sekret.link/storage/postgresql"
@@ -64,47 +63,11 @@ func scheduleDeleteExpired(ctx context.Context, entryStorage storage.Writer) {
 
 func listen(handlerConfig api.HandlerConfig) *http.Server {
 	mux := http.NewServeMux()
-	secretHandler := api.NewSecretHandler(handlerConfig)
 
 	apiRoot := getAPIRoot(handlerConfig.WebExternalURL)
-	mux.Handle(
-		fmt.Sprintf("GET %s", apiRoot),
-		http.StripPrefix(
-			apiRoot,
-			middlewares.SetupLogging(
-				middlewares.SetupHeaders(http.HandlerFunc(secretHandler.Get)),
-			),
-		),
-	)
-	mux.Handle(
-		fmt.Sprintf("POST %s", apiRoot),
-		http.StripPrefix(
-			apiRoot,
-			middlewares.SetupLogging(
-				middlewares.SetupHeaders(http.HandlerFunc(secretHandler.Post)),
-			),
-		),
-	)
 
-	mux.Handle(
-		fmt.Sprintf("DELETE %s", apiRoot),
-		http.StripPrefix(
-			apiRoot,
-			middlewares.SetupLogging(
-				middlewares.SetupHeaders(http.HandlerFunc(secretHandler.Delete)),
-			),
-		),
-	)
-
-	mux.Handle(
-		fmt.Sprintf("OPTIONS %s", apiRoot),
-		http.StripPrefix(
-			apiRoot,
-			middlewares.SetupLogging(
-				middlewares.SetupHeaders(http.HandlerFunc(secretHandler.Options)),
-			),
-		),
-	)
+	secretHandler := api.NewSecretHandler(handlerConfig)
+	secretHandler.RegisterHandlers(mux, apiRoot)
 
 	httpServer := &http.Server{
 		Addr:         ":8080",

internal/api/getentry.go

@@ -47,7 +47,7 @@ func (g GetHandler) handle(w http.ResponseWriter, r *http.Request) error {
 	request, err := g.parser.Parse(r)
 
 	if err != nil {
-		return errors.Join(ErrRequestParseError, err)
+		return err
 	}
 
 	ctx, cancel := context.WithCancel(context.Background())

internal/parsers/errors.go

@@ -20,3 +20,6 @@ var ErrInvalidURL = errors.New("invalid URL")
 
 // ErrInvalidUUID is returned when the UUID is invalid
 var ErrInvalidUUID = errors.New("invalid UUID")
+
+// ErrInvalidKey is returned when the key is invalid
+var ErrInvalidKey = errors.New("invalid key")

internal/parsers/getentry.go

@@ -3,8 +3,8 @@ package parsers
 import (
 	"encoding/hex"
 	"errors"
+	"fmt"
 	"net/http"
-	"path"
 
 	"github.com/google/uuid"
 )
@@ -21,14 +21,15 @@ type GetEntryRequestData struct {
 	Key       []byte
 }
 
-func (g GetEntryParser) Parse(u *http.Request) (GetEntryRequestData, error) {
-	urlPath := u.URL.Path
-	pathDir, keyString := path.Split(urlPath)
+func (g GetEntryParser) Parse(req *http.Request) (GetEntryRequestData, error) {
 	var reqData GetEntryRequestData
-	if len(pathDir) < 1 {
-		return reqData, ErrInvalidURL
+	keyString := req.PathValue("key")
+	if keyString == "" {
+		fmt.Println("EMPTY KEY", req.URL.Path)
+		return reqData, ErrInvalidKey
 	}
-	_, uuidFromPath := path.Split(pathDir[0 : len(pathDir)-1])
+
+	uuidFromPath := req.PathValue("uuid")
 	UUID, err := uuid.Parse(uuidFromPath)
 
 	if err != nil {
@@ -37,7 +38,7 @@ func (g GetEntryParser) Parse(u *http.Request) (GetEntryRequestData, error) {
 	key, err := hex.DecodeString(keyString)
 
 	if err != nil {
-		return reqData, err
+		return reqData, errors.Join(ErrInvalidKey, err)
 	}
 	return GetEntryRequestData{UUID: UUID.String(), Key: key, KeyString: keyString}, nil
 }

internal/views/response.go

@@ -4,7 +4,6 @@ import (
 	"crypto/aes"
 	"encoding/hex"
 	"errors"
-	"log"
 	"net/http"
 	"strings"
 
@@ -18,7 +17,6 @@ import (
 var ErrCreateKey = errors.New("create key failed")
 
 func (e EntryView) RenderCreateEntryErrorResponse(w http.ResponseWriter, r *http.Request, err error) {
-	log.Println("CREATE ENTRY ERROR", err)
 	if errors.Is(err, parsers.ErrInvalidExpirationDate) {
 		http.Error(w, "Invalid expiration", http.StatusBadRequest)
 		return
@@ -35,7 +33,6 @@ func (e EntryView) RenderCreateEntryErrorResponse(w http.ResponseWriter, r *http
 }
 
 func (e EntryView) RenderReadEntryError(w http.ResponseWriter, r *http.Request, err error) {
-	log.Println(err)
 	if errors.Is(err, services.ErrEntryExpired) {
 		http.Error(w, "Gone", http.StatusGone)
 		return
@@ -46,6 +43,16 @@ func (e EntryView) RenderReadEntryError(w http.ResponseWriter, r *http.Request,
 		return
 	}
 
+	if errors.Is(err, parsers.ErrInvalidUUID) {
+		http.Error(w, "Bad request", http.StatusBadRequest)
+		return
+	}
+
+	if errors.Is(err, parsers.ErrInvalidKey) {
+		http.Error(w, "Bad request", http.StatusBadRequest)
+		return
+	}
+
 	if errors.Is(err, hex.ErrLength) {
 		http.Error(w, "Bad request", http.StatusBadRequest)
 		return
@@ -61,7 +68,6 @@ func (e EntryView) RenderReadEntryError(w http.ResponseWriter, r *http.Request,
 }
 
 func (e EntryView) RenderDeleteEntryError(w http.ResponseWriter, r *http.Request, err error) {
-	log.Println(err)
 
 	if errors.Is(err, entries.ErrEntryNotFound) || errors.Is(err, models.ErrEntryNotFound) {
 		http.Error(w, "Not Found", http.StatusNotFound)