finished implementing new error handler

handlers/auth.go

@@ -1,11 +1,10 @@
 package handlers
 
 import (
-	"errors"
+	"fmt"
 	"github.com/gofiber/fiber/v2"
 	"github.com/golang-jwt/jwt/v5"
 	"golang.org/x/crypto/bcrypt"
-	"log"
 	"os"
 	"relay-server/config"
 	"relay-server/database"
@@ -14,154 +13,162 @@ import (
 )
 
 func Signup(c *fiber.Ctx) error {
-
 	type SignupStruct struct {
 		Username string `json:"username" xml:"username" form:"username"`
 		Password string `json:"password" xml:"password" form:"password"`
 	}
 
-	db := database.DB
 	u := new(SignupStruct)
 	if err := c.BodyParser(u); err != nil {
-		return err
+		return helpers.NewError(helpers.ErrInvalidInput, "Invalid request body", err)
 	}
-	// Checks if username or passwords are empty
+
+	// Validate input
 	if u.Username == "" {
-		return c.Status(fiber.StatusBadRequest).JSON(fiber.Map{"error": "username is empty"})
+		return helpers.NewError(helpers.ErrInvalidInput, "Username is empty", nil)
 	}
 	if u.Password == "" {
-		return c.Status(fiber.StatusBadRequest).JSON(fiber.Map{"error": "password is empty"})
+		return helpers.NewError(helpers.ErrInvalidInput, "Password is empty", nil)
 	}
-
-	// Checks if passwords or username have valid length and characters
 	if !helpers.IsValidPassword(u.Password) {
-		return c.Status(fiber.StatusBadRequest).JSON(fiber.Map{"error": "invalid password"})
+		return helpers.NewError(helpers.ErrInvalidInput, "Invalid password", nil)
 	}
 	if !helpers.IsValidUsername(u.Username) {
-		return c.Status(fiber.StatusBadRequest).JSON(fiber.Map{"error": "invalid username"})
+		return helpers.NewError(helpers.ErrInvalidInput, "Invalid username", nil)
 	}
 
-	// Checks if username already exist in database
-	exist, _ := database.CheckUserExists(db, u.Username)
+	// Check if user exists
+	exist, err := database.CheckUserExists(database.DB, u.Username)
+	if err != nil {
+		return helpers.NewError(helpers.ErrInternal, "internal server error", fmt.Errorf("failed to check user existance: %w", err))
+	}
 	if exist {
-		return c.Status(fiber.StatusBadRequest).JSON(fiber.Map{"error": "user already exists"})
+		return helpers.NewError(helpers.ErrInvalidInput, "User already exists", nil)
 	}
 
 	// Create password hash
 	passwordHash, err := bcrypt.GenerateFromPassword([]byte(u.Password), config.BCRYPT_COST)
 	if err != nil {
-		log.Printf("error hashing password: %w\n", err)
-		return c.Status(fiber.StatusInternalServerError).JSON(fiber.Map{"error": "internal server error"})
+		return helpers.NewError(helpers.ErrInternal, "internal server error", fmt.Errorf("failed to generate password hash: %w", err))
 	}
 
-	// Insert username and password hash to database
-	userID, err := database.InsertUser(db, u.Username, string(passwordHash))
+	// Insert user
+	userID, err := database.InsertUser(database.DB, u.Username, string(passwordHash))
 	if err != nil {
-		log.Print(err)
-		return c.Status(fiber.StatusInternalServerError).JSON(fiber.Map{"error": "Internal server error"})
+		return helpers.NewError(helpers.ErrInternal, "Failed to create user", err)
 	}
 
-	// Generate token with user id and username
+	// Generate token
 	token := jwt.NewWithClaims(jwt.SigningMethodHS256, jwt.MapClaims{
 		"user_id":  userID,
 		"username": u.Username,
 	})
-	// Sign token
 	signedToken, err := token.SignedString([]byte(os.Getenv("JWT_SECRET")))
+	if err != nil {
+		return helpers.NewError(helpers.ErrInternal, "Failed to generate auth token", err)
+	}
 
-	// Set token to cookies
+	// Set token cookie
 	tokenCookie := new(fiber.Cookie)
 	tokenCookie.Name = "token"
 	tokenCookie.Value = signedToken
 	tokenCookie.Expires = time.Now().Add(30 * 24 * time.Hour)
-	//tokenCookie.HTTPOnly = true
 	c.Cookie(tokenCookie)
 
-	// If everything went well sent username and user_id assigned by database
-	return c.Status(fiber.StatusOK).JSON(fiber.Map{"message": "Successfully signed up", "username": u.Username, "user_id": userID})
+	return c.Status(fiber.StatusOK).JSON(fiber.Map{
+		"message":  "Successfully signed up",
+		"username": u.Username,
+		"user_id":  userID,
+	})
 }
 
 func Login(c *fiber.Ctx) error {
-
 	type loginStruct struct {
 		Username string `json:"username" xml:"username" form:"username"`
 		Password string `json:"password" xml:"password" form:"password"`
 	}
 
-	db := database.DB
 	u := new(loginStruct)
-
 	if err := c.BodyParser(u); err != nil {
+		return helpers.NewError(helpers.ErrInvalidInput, "Invalid request body", err)
+	}
+
+	// Validate input
+	if u.Username == "" {
+		return helpers.NewError(helpers.ErrInvalidInput, "Username is empty", nil)
+	}
+	if u.Password == "" {
+		return helpers.NewError(helpers.ErrInvalidInput, "Password is empty", nil)
+	}
+	if !helpers.IsValidUsername(u.Username) {
+		return helpers.NewError(helpers.ErrInvalidInput, "Invalid username", nil)
+	}
+	if !helpers.IsValidPassword(u.Password) {
+		return helpers.NewError(helpers.ErrInvalidInput, "Invalid password", nil)
+	}
+
+	// Check if user exists
+	exist, err := database.CheckUserExists(database.DB, u.Username)
+	if err != nil {
+		return err
+	}
+	if !exist {
+		return helpers.NewError(helpers.ErrNotFound, "User does not exist", nil)
+	}
+
+	// Verify password
+	passwordHash, err := database.GetPasswordHash(database.DB, u.Username)
+	if err != nil {
+		return err
+	}
+	if err := bcrypt.CompareHashAndPassword([]byte(passwordHash), []byte(u.Password)); err != nil {
+		return helpers.NewError(helpers.ErrInvalidInput, "Invalid password", nil)
+	}
+
+	// Get user ID
+	userID, err := database.GetUserID(database.DB, u.Username)
+	if err != nil {
 		return err
 	}
 
-	// Checks if username or passwords are empty
-	if u.Username == "" {
-		return c.Status(fiber.StatusBadRequest).JSON(fiber.Map{"error": "username is empty"})
-	}
-	if u.Password == "" {
-		return c.Status(fiber.StatusBadRequest).JSON(fiber.Map{"error": "password is empty"})
-	}
-
-	// Checks if username or passwords have valid length and characters
-	if !helpers.IsValidUsername(u.Username) {
-		return c.Status(fiber.StatusBadRequest).JSON(fiber.Map{"error": "invalid username"})
-	}
-	if !helpers.IsValidPassword(u.Password) {
-		return c.Status(fiber.StatusBadRequest).JSON(fiber.Map{"error": "invalid password"})
-	}
-
-	// Checks if username exist in database
-	exist, _ := database.CheckUserExists(db, u.Username)
-	if !exist {
-		return c.Status(fiber.StatusBadRequest).JSON(fiber.Map{"error": "user does not exists"})
-	}
-
-	// Verifies password matching
-	passwordHash, err := database.GetPasswordHash(db, u.Username)
-	if err != nil {
-		log.Printf("error getting password: %w\n", err)
-	}
-	if bcrypt.CompareHashAndPassword([]byte(passwordHash), []byte(u.Password)) != nil {
-		return c.Status(fiber.StatusUnauthorized).JSON(fiber.Map{"error": "invalid password"})
-	}
-
-	userID, err := database.GetUserID(db, u.Username)
-	if err != nil {
-		var e *helpers.Error
-		if errors.As(err, &e) {
-			return c.Status(fiber.StatusBadRequest).JSON(fiber.Map{"message": "user does not exist"})
-		}
-		log.Println(err)
-		return c.Status(fiber.StatusInternalServerError).JSON(fiber.Map{"message": "Internal server error"})
-	}
-	// Generate token with user id and username
+	// Generate token
 	token := jwt.NewWithClaims(jwt.SigningMethodHS256, jwt.MapClaims{
 		"user_id":  userID,
 		"username": u.Username,
 	})
-	// Sign token
 	signedToken, err := token.SignedString([]byte(os.Getenv("JWT_SECRET")))
+	if err != nil {
+		return helpers.NewError(helpers.ErrInternal, "Failed to generate token", err)
+	}
 
-	// Set token to cookies
+	// Set token cookie
 	tokenCookie := new(fiber.Cookie)
 	tokenCookie.Name = "token"
 	tokenCookie.Value = signedToken
 	tokenCookie.Expires = time.Now().Add(30 * 24 * time.Hour)
 	c.Cookie(tokenCookie)
 
-	return c.Status(fiber.StatusOK).JSON(fiber.Map{"message": "Successfully logged in", "username": u.Username, "user_id": userID})
+	return c.Status(fiber.StatusOK).JSON(fiber.Map{
+		"message":  "Successfully logged in",
+		"username": u.Username,
+		"user_id":  userID,
+	})
 }
 
 func ValidateToken(c *fiber.Ctx) error {
-	username := c.Locals("username").(string)
-	userID := c.Locals("userID").(string)
+	username, ok := c.Locals("username").(string)
+	if !ok {
+		return helpers.NewError(helpers.ErrInvalidInput, "Invalid token: missing username", nil)
+	}
 
-	//log.Printf("userID: %v, username: %v", userID, username)
-	//if userID == "" || username == "" {
-	//	log.Printf("userID or username is empty %v", c.Locals("username"))
-	//	return c.Status(fiber.StatusBadRequest).JSON(fiber.Map{"error": "invalid token"})
-	//}
+	userID, ok := c.Locals("userID").(string)
+	if !ok {
+		return helpers.NewError(helpers.ErrInvalidInput, "Invalid token: missing user ID", nil)
+	}
 
-	return c.Status(fiber.StatusOK).JSON(fiber.Map{"message": "authorized", "username": username, "user_id": userID})
+	return c.Status(fiber.StatusOK).JSON(fiber.Map{
+		"message":  "authorized",
+		"username": username,
+		"user_id":  userID,
+	})
 }

handlers/contacts.go

@@ -25,13 +25,10 @@ func DeleteContact(c *fiber.Ctx) error {
 		return helpers.NewError(helpers.ErrInvalidInput, "conversation ID is empty", nil)
 	}
 
-	msg, err := database.DeleteContact(database.DB, p.ContactID, p.ConversationID)
+	err := database.DeleteContact(database.DB, p.ContactID, p.ConversationID)
 	if err != nil {
 		return helpers.NewError(helpers.ErrInternal, "Failed to delete contact", err)
 	}
-	if msg != "" {
-		return helpers.NewError(helpers.ErrInvalidInput, msg, nil)
-	}
 
 	return c.Status(fiber.StatusOK).JSON(fiber.Map{"message": "Contact deleted"})
 }