fix: 243 tx to InTx for account,tab,user

Author: the-npden4ik

Diff for: modules/core/handlers/tab_handler.go

@@ -2,10 +2,11 @@ package handlers
 
 import (
 	"context"
-
 	"github.com/iota-uz/iota-sdk/modules/core/domain/aggregates/user"
 	"github.com/iota-uz/iota-sdk/modules/core/domain/entities/tab"
+	"github.com/iota-uz/iota-sdk/modules/core/services"
 	"github.com/iota-uz/iota-sdk/pkg/application"
+	"github.com/iota-uz/iota-sdk/pkg/composables"
 	"github.com/iota-uz/iota-sdk/pkg/constants"
 	"github.com/iota-uz/iota-sdk/pkg/eventbus"
 	"github.com/iota-uz/iota-sdk/pkg/types"
@@ -14,20 +15,19 @@ import (
 )
 
 type TabHandler struct {
-	app        application.Application
-	tabService tab.Repository
-	logger     *logrus.Logger
+	app     application.Application
+	service *services.TabService
+	logger  *logrus.Logger
 }
 
 func NewTabHandler(
 	app application.Application,
-	tabService tab.Repository,
 	logger *logrus.Logger,
 ) *TabHandler {
 	return &TabHandler{
-		app:        app,
-		tabService: tabService,
-		logger:     logger,
+		app:     app,
+		service: app.Service(services.TabService{}).(*services.TabService),
+		logger:  logger,
 	}
 }
 
@@ -36,7 +36,8 @@ func (h *TabHandler) Register(publisher eventbus.EventBus) {
 }
 
 func (h *TabHandler) HandleUserCreated(event *user.CreatedEvent) {
-	h.createUserTabs(context.Background(), event.Result)
+	ctx := composables.WithPool(context.Background(), h.app.DB())
+	h.createUserTabs(ctx, event.Result)
 }
 
 func (h *TabHandler) createUserTabs(ctx context.Context, user user.User) {
@@ -48,9 +49,9 @@ func (h *TabHandler) createUserTabs(ctx context.Context, user user.User) {
 	items := h.app.NavItems(i18n.NewLocalizer(h.app.Bundle(), string(user.UILanguage())))
 	hrefs := h.getAccessibleNavItems(items, user)
 
-	tabs := make([]*tab.Tab, 0, len(hrefs))
+	tabs := make([]*tab.CreateDTO, 0, len(hrefs))
 	for i, href := range hrefs {
-		tabs = append(tabs, &tab.Tab{
+		tabs = append(tabs, &tab.CreateDTO{
 			UserID:   user.ID(),
 			Href:     href,
 			Position: uint(i),
@@ -59,13 +60,11 @@ func (h *TabHandler) createUserTabs(ctx context.Context, user user.User) {
 
 	if len(tabs) > 0 {
 		ctxWithUser := context.WithValue(ctx, constants.UserKey, user)
-		if err := h.tabService.DeleteUserTabs(ctxWithUser, user.ID()); err != nil {
-			h.logger.Errorf("Failed to delete existing tabs for user %d: %v", user.ID(), err)
+		_, err := h.service.CreateManyUserTabs(ctxWithUser, user.ID(), tabs)
+		if err != nil {
+			h.logger.Errorf("Failed to create tabs for user %d: %v", user.ID(), err)
 			return
 		}
-		if err := h.tabService.CreateMany(ctxWithUser, tabs); err != nil {
-			h.logger.Errorf("Failed to create tab for user %d: %v", user.ID(), err)
-		}
 	}
 }
 

Diff for: modules/core/module.go

@@ -64,13 +64,11 @@ func (m *Module) Register(app application.Application) error {
 		services.NewRoleService(roleRepo, app.EventPublisher()),
 		services.NewPermissionService(permRepo, app.EventPublisher()),
 		services.NewTabService(persistence.NewTabRepository()),
-		services.NewTabService(persistence.NewTabRepository()),
 		services.NewGroupService(persistence.NewGroupRepository(userRepo, roleRepo), app.EventPublisher()),
 	)
 
 	tabHandler := handlers.NewTabHandler(
 		app,
-		persistence.NewTabRepository(),
 		configuration.Use().Logger(),
 	)
 	tabHandler.Register(app.EventPublisher())

Diff for: modules/core/presentation/controllers/account_controller.go

@@ -55,7 +55,6 @@ func (c *AccountController) Register(r *mux.Router) {
 
 	setRouter := r.PathPrefix(c.basePath).Subrouter()
 	setRouter.Use(commonMiddleware...)
-	setRouter.Use(middleware.WithTransaction())
 	setRouter.HandleFunc("", c.Update).Methods(http.MethodPost)
 	setRouter.HandleFunc("/sidebar", c.PostSettings).Methods(http.MethodPost)
 }

Diff for: modules/core/services/tab_service.go

@@ -2,8 +2,8 @@ package services
 
 import (
 	"context"
-
 	"github.com/iota-uz/iota-sdk/modules/core/domain/entities/tab"
+	"github.com/iota-uz/iota-sdk/pkg/composables"
 )
 
 type TabService struct {
@@ -46,10 +46,16 @@ func (s *TabService) CreateManyUserTabs(ctx context.Context, userID uint, data [
 		}
 		entities = append(entities, entity)
 	}
-	if err := s.repo.DeleteUserTabs(ctx, userID); err != nil {
-		return nil, err
-	}
-	if err := s.repo.CreateMany(ctx, entities); err != nil {
+	err := composables.InTx(ctx, func(txCtx context.Context) error {
+		if err := s.repo.DeleteUserTabs(txCtx, userID); err != nil {
+			return err
+		}
+		if err := s.repo.CreateMany(txCtx, entities); err != nil {
+			return err
+		}
+		return nil
+	})
+	if err != nil {
 		return nil, err
 	}
 	return entities, nil

Diff for: modules/core/services/user_service.go

@@ -65,41 +65,39 @@ func (s *UserService) GetPaginatedWithTotal(ctx context.Context, params *user.Fi
 }
 
 func (s *UserService) Create(ctx context.Context, data user.User) error {
-	if err := composables.CanUser(ctx, permissions.UserCreate); err != nil {
-		return err
-	}
-	if err := s.validator.ValidateCreate(ctx, data); err != nil {
-		return err
-	}
-	logger := composables.UseLogger(ctx)
-	tx, err := composables.BeginTx(ctx)
+	err := composables.CanUser(ctx, permissions.UserCreate)
 	if err != nil {
 		return err
 	}
-	defer func() {
-		if err := tx.Rollback(ctx); err != nil {
-			logger.WithError(err).Error("failed to rollback transaction")
-		}
-	}()
-	createdEvent, err := user.NewCreatedEvent(ctx, data)
+	err = s.validator.ValidateCreate(ctx, data)
 	if err != nil {
 		return err
 	}
 	data, err = data.SetPassword(data.Password())
+
+	var createdUser user.User
+	err = composables.InTx(ctx, func(txCtx context.Context) error {
+		if err != nil {
+			return err
+		}
+		created, err := s.repo.Create(ctx, data)
+		if err != nil {
+			return err
+		}
+		createdUser = created
+		return nil
+	})
 	if err != nil {
 		return err
 	}
-	created, err := s.repo.Create(ctx, data)
+	createdEvent, err := user.NewCreatedEvent(ctx, data)
 	if err != nil {
 		return err
 	}
-
-	if err := tx.Commit(ctx); err != nil {
-		return err
-	}
-	createdEvent.Result = created
+	createdEvent.Result = createdUser
 	s.publisher.Publish(createdEvent)
-	return nil
+
+	return err
 }
 
 func (s *UserService) UpdateLastAction(ctx context.Context, id uint) error {