refac: hardening pass with multiple overhauls

internal/infrastructure/persistence/repositories/inviteRepository.go

@@ -2,6 +2,7 @@ package persistence
 
 import (
 	domainInvite "RenewCMS/internal/domain/invite"
+	domainUser "RenewCMS/internal/domain/user"
 	"RenewCMS/internal/infrastructure/persistence/mappers"
 	entity "RenewCMS/internal/infrastructure/persistence/models"
 	"time"
@@ -44,9 +45,22 @@ func (i *InviteRepository) Delete(id uint32) error {
 	return deleteOrNotFound(result, domainInvite.ErrInviteNotFound)
 }
 
-func (i *InviteRepository) MarkAccepted(id uint32, acceptedAt time.Time) error {
-	result := i.db.Model(&entity.Invite{}).Where("id = ?", id).Update("accepted_at", acceptedAt)
-	return deleteOrNotFound(result, domainInvite.ErrInviteNotFound)
+func (i *InviteRepository) AcceptWithUser(inviteID uint32, acceptedAt time.Time, newUser domainUser.User) (domainUser.User, error) {
+	createdModel := mappers.UserToModel(newUser)
+	err := i.db.Transaction(func(tx *gorm.DB) error {
+		marked := tx.Model(&entity.Invite{}).
+			Where("id = ? AND accepted_at IS NULL", inviteID).
+			Update("accepted_at", acceptedAt)
+		if err := deleteOrNotFound(marked, domainInvite.ErrInviteNotFound); err != nil {
+			return err
+		}
+		return tx.Create(&createdModel).Error
+	})
+	if err != nil {
+		return domainUser.User{}, err
+	}
+
+	return mappers.UserToDomain(createdModel), nil
 }
 
 var _ domainInvite.Repository = &InviteRepository{}

internal/infrastructure/persistence/repositories/userRepository.go

@@ -49,7 +49,7 @@ func (u *UserRepository) Create(user domainUser.User) (domainUser.User, error) {
 }
 
 func (u *UserRepository) Delete(id uint32) error {
-	result := u.db.Delete(&domainUser.User{}, id)
+	result := u.db.Delete(&entity.User{}, id)
 	return deleteOrNotFound(result, domainUser.ErrUserNotFound)
 }
 

internal/infrastructure/useCases/AcceptInvite.go

@@ -34,6 +34,9 @@ func (a *AcceptInviteUseCase) AcceptInvite(command AcceptInviteCommand) (user.Us
 	}
 
 	if a.emailHasAccount(pending.Email) {
+		if _, err := findUsableInvite(a.inviteRepository, a.hasher, command.Code, now); err != nil {
+			return user.User{}, err
+		}
 		return user.User{}, invite.ErrEmailHasAccount
 	}
 
@@ -46,20 +49,16 @@ func (a *AcceptInviteUseCase) AcceptInvite(command AcceptInviteCommand) (user.Us
 		return user.User{}, err
 	}
 
-	createdUser, err := a.userRepository.Create(user.User{
+	createdUser, err := a.inviteRepository.AcceptWithUser(pending.ID, now, user.User{
 		Username:   command.Username,
 		Password:   hashedPassword,
 		Email:      pending.Email,
 		IsVerified: true,
 	})
-	if err != nil {
-		return user.User{}, err
+	if errors.Is(err, invite.ErrInviteNotFound) {
+		return user.User{}, invite.ErrInviteInvalid
 	}
-
-	if err := a.inviteRepository.MarkAccepted(pending.ID, now); err != nil {
-		if deleteErr := a.userRepository.Delete(createdUser.ID); deleteErr != nil {
-			return user.User{}, errors.Join(err, deleteErr)
-		}
+	if err != nil {
 		return user.User{}, err
 	}