refactor(service): use Errorf instead of errors.Join

repository/repository.go

@@ -10,6 +10,8 @@ import (
 	"forge.capytal.company/loreddev/x/tinyssert"
 )
 
+// TODO: Add rowback to all return errors, or use context to cancel operations
+
 type baseRepostiory struct {
 	db *sql.DB
 

service/token.go

@@ -58,7 +58,7 @@ func (svc *Token) Issue(user model.User) (string, error) { // TODO: Return a ref
 
 	jti, err := uuid.NewV7()
 	if err != nil {
-		return "", errors.Join(errors.New("service: failed to generate token UUID"), err)
+		return "", fmt.Errorf("service: failed to generate token UUID: %w", err)
 	}
 
 	now := time.Now()
@@ -76,7 +76,7 @@ func (svc *Token) Issue(user model.User) (string, error) { // TODO: Return a ref
 
 	signed, err := t.SignedString(svc.privateKey)
 	if err != nil {
-		return "", errors.Join(errors.New("service: failed to sign token"), err)
+		return "", fmt.Errorf("service: failed to sign token: %w", err)
 	}
 
 	// TODO: Store refresh tokens in repo
@@ -87,7 +87,7 @@ func (svc *Token) Issue(user model.User) (string, error) { // TODO: Return a ref
 		DateExpires: expires,
 	})
 	if err != nil {
-		return "", errors.Join(errors.New("service: failed to save token"), err)
+		return "", fmt.Errorf("service: failed to save token: %w", err)
 	}
 
 	return signed, nil
@@ -106,7 +106,7 @@ func (svc Token) Parse(tokenStr string) (*jwt.Token, error) {
 	}, jwt.WithValidMethods([]string{(&jwt.SigningMethodEd25519{}).Alg()}))
 	if err != nil {
 		log.Error("Invalid token", slog.String("error", err.Error()))
-		return nil, errors.Join(errors.New("service: invalid token"), err)
+		return nil, fmt.Errorf("service: invalid token: %w", err)
 	}
 
 	// TODO: Check issuer and if the token was issued at the correct date
@@ -114,7 +114,7 @@ func (svc Token) Parse(tokenStr string) (*jwt.Token, error) {
 	_, ok := token.Claims.(jwt.MapClaims)
 	if !ok {
 		log.Error("Invalid claims type", slog.String("claims", fmt.Sprintf("%#v", token.Claims)))
-		return nil, errors.New("service: invalid claims type")
+		return nil, fmt.Errorf("service: invalid claims type")
 	}
 
 	return token, nil
@@ -136,18 +136,18 @@ func (svc Token) Revoke(token *jwt.Token) error {
 
 	jti, err := uuid.Parse(claims.ID)
 	if err != nil {
-		return errors.Join(errors.New("service: invalid token UUID"), err)
+		return fmt.Errorf("service: invalid token UUID: %w", err)
 	}
 
 	user, err := uuid.Parse(claims.Subject)
 	if err != nil {
-		return errors.Join(errors.New("service: invalid token subject UUID"), err)
+		return fmt.Errorf("service: invalid token subject UUID: %w", err)
 	}
 
 	// TODO: Mark tokens as revoked instead of deleting them
 	err = svc.repo.Delete(jti, user)
 	if err != nil {
-		return errors.Join(errors.New("service: failed to delete token"), err)
+		return fmt.Errorf("service: failed to delete token: %w", err)
 	}
 
 	return nil
@@ -169,19 +169,19 @@ func (svc Token) IsRevoked(token *jwt.Token) (bool, error) {
 
 	jti, err := uuid.Parse(claims.ID)
 	if err != nil {
-		return false, errors.Join(errors.New("service: invalid token UUID"), err)
+		return false, fmt.Errorf("service: invalid token UUID: %w", err)
 	}
 
 	user, err := uuid.Parse(claims.Subject)
 	if err != nil {
-		return false, errors.Join(errors.New("service: invalid token subject UUID"), err)
+		return false, fmt.Errorf("service: invalid token subject UUID: %w", err)
 	}
 
 	_, err = svc.repo.Get(jti, user)
 	if errors.Is(err, repository.ErrNotFound) {
 		return true, nil
 	} else if err != nil {
-		return false, errors.Join(errors.New("service: failed to get token"), err)
+		return false, fmt.Errorf("service: failed to get token: %w", err)
 	}
 
 	return false, nil

service/user.go

@@ -2,6 +2,7 @@ package service
 
 import (
 	"errors"
+	"fmt"
 	"log/slog"
 	"time"
 
@@ -40,12 +41,12 @@ func (svc *User) Register(username, password string) (model.User, error) {
 
 	hash, err := bcrypt.GenerateFromPassword([]byte(password), bcrypt.DefaultCost)
 	if err != nil {
-		return model.User{}, errors.Join(errors.New("service: unable to generate password hash"))
+		return model.User{}, errors.New("service: unable to generate password hash")
 	}
 
 	id, err := uuid.NewV7()
 	if err != nil {
-		return model.User{}, errors.Join(errors.New("service: unable to create user id"), err)
+		return model.User{}, fmt.Errorf("service: unable to create user id", err)
 	}
 
 	now := time.Now()
@@ -60,7 +61,7 @@ func (svc *User) Register(username, password string) (model.User, error) {
 
 	u, err = svc.repo.Create(u)
 	if err != nil {
-		return model.User{}, errors.Join(errors.New("service: failed to create user model"), err)
+		return model.User{}, fmt.Errorf("service: failed to create user model: %w", err)
 	}
 
 	return u, nil
@@ -76,12 +77,12 @@ func (svc *User) Login(username, password string) (user model.User, err error) {
 
 	user, err = svc.repo.GetByUsername(username)
 	if err != nil {
-		return model.User{}, errors.Join(errors.New("service: unable to find user"), err)
+		return model.User{}, fmt.Errorf("service: unable to find user: %w", err)
 	}
 
 	err = bcrypt.CompareHashAndPassword(user.Password, []byte(password))
 	if err != nil {
-		return model.User{}, errors.Join(errors.New("service: unable to compare passwords"), err)
+		return model.User{}, fmt.Errorf("service: unable to compare passwords: %w", err)
 	}
 
 	return user, nil