codeword/internal/app/app.go

package app

import (
	"codeword/internal/controller/promocode"
	"codeword/internal/controller/recovery"
	"codeword/internal/initialize"
	"codeword/internal/repository"
	httpserver "codeword/internal/server/http"
	"codeword/internal/services"
	"codeword/internal/worker/purge_worker"
	"codeword/internal/worker/recovery_worker"
	"context"
	"go.mongodb.org/mongo-driver/mongo"
	"go.uber.org/zap"
)

func Run(ctx context.Context, cfg initialize.Config, logger *zap.Logger) error {
	logger.Info("Запуск приложения", zap.String("AppName", cfg.AppName))

	ctx, cancel := context.WithCancel(ctx)
	defer cancel()

	mdb, err := initialize.MongoDB(ctx, cfg)
	if err != nil {
		logger.Error("Failed to initialize MongoDB", zap.Error(err))
		cancel()
	}

	rdb, err := initialize.Redis(ctx, cfg)
	encrypt := initialize.Encrypt(cfg)

	promoCodeRepo := repository.NewPromoCodeRepository(mdb.Collection("promoCodes"))
	codewordRepo := repository.NewCodewordRepository(repository.Deps{Rdb: rdb, Mdb: mdb.Collection("codeword")})
	userRepo := repository.NewUserRepository(repository.Deps{Rdb: nil, Mdb: mdb.Collection("users")})

	recoveryEmailSender := initialize.RecoveryEmailSender(cfg, logger)
	authClient := initialize.AuthClient(cfg, logger)

	recoveryService := services.NewRecoveryService(services.Deps{
		Logger:             logger,
		CodewordRepository: codewordRepo,
		UserRepository:     userRepo,
		Encrypt:            encrypt,
		AuthClient:         authClient,
	})

	promoService := services.NewPromoCodeService(services.PromoDeps{
		Logger:        logger,
		PromoCodeRepo: promoCodeRepo,
	})

	recoveryController := recovery.NewRecoveryController(logger, recoveryService, cfg.DefaultRedirectionURL)
	promoCodeController := promocode.NewPromoCodeController(logger, promoService)

	recoveryWC := recovery_worker.NewRecoveryWC(recovery_worker.Deps{
		Logger:      logger,
		Redis:       rdb,
		EmailSender: recoveryEmailSender,
		Mongo:       mdb.Collection("codeword"),
	})

	purgeWC := purge_worker.NewRecoveryWC(purge_worker.Deps{
		Logger: logger,
		Mongo:  mdb.Collection("codeword"),
	})

	go recoveryWC.Start(ctx)
	go purgeWC.Start(ctx)

	server := httpserver.NewServer(httpserver.ServerConfig{
		Logger:              logger,
		RecoveryController:  recoveryController,
		PromoCodeController: promoCodeController,
	})

	go func() {
		if err := server.Start(cfg.HTTPHost + ":" + cfg.HTTPPort); err != nil {
			logger.Error("Server startup error", zap.Error(err))
		}
	}()

	<-ctx.Done()

	if err := shutdownApp(ctx, server, mdb, logger); err != nil {
		return err
	}
	logger.Info("The application has stopped")
	return nil
}

// TODO возможно стоит вынести в отдельные файлы или отказаться от разделения на отдельные методы

func shutdownApp(ctx context.Context, server *httpserver.Server, mdb *mongo.Database, logger *zap.Logger) error {
	if err := shutdownHTTPServer(ctx, server, logger); err != nil {
		return err
	}

	if err := shutdownMongoDB(ctx, mdb, logger); err != nil {
		return err
	}

	return nil
}

func shutdownHTTPServer(ctx context.Context, server *httpserver.Server, logger *zap.Logger) error {
	if err := server.Shutdown(ctx); err != nil {
		logger.Error("Error stopping HTTP server", zap.Error(err))
		return err
	}
	return nil
}

func shutdownMongoDB(ctx context.Context, mdb *mongo.Database, logger *zap.Logger) error {
	if err := mdb.Client().Disconnect(ctx); err != nil {
		logger.Error("Error when closing MongoDB connection", zap.Error(err))
		return err
	}
	return nil
}