notifier/internal/app/app.go

package app

import (
	"context"
	"go.uber.org/zap"
	"mailnotifier/internal/clients"
	"mailnotifier/internal/initialize"
	"mailnotifier/internal/models"
	"mailnotifier/internal/repository"
	"mailnotifier/internal/workers"
)

func Run(ctx context.Context, config initialize.Config, logger *zap.Logger) error {
	defer func() {
		if r := recover(); r != nil {
			logger.Error("Recovered from a panic", zap.Any("error", r))
		}
	}()

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

	// todo обдумать буфер чтобы не было блокировок, хотя это не предугадать но оптимально подстроить можно
	welcomeChan := make(chan models.Message, 50)

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

	kafka, err := initialize.KafkaConsumerInit(ctx, config)

	repo := repository.NewRepository(mdb.Collection("notify"), welcomeChan)

	mailClient := clients.NewMailClient(clients.Deps{
		SmtpHost:   config.SmtpHost,
		SmtpApiUrl: config.SmtpApiUrl,
		SmtpPort:   config.SmtpPort,
		SmtpSender: config.SmtpSender,
		Username:   config.SmtpUsername,
		Password:   config.SmtpPassword,
		ApiKey:     config.SmtpApiKey,
		Logger:     logger,
	})

	customerClient := clients.NewCustomerClient(clients.CustomerDeps{
		Url:    config.CustomerURL,
		Logger: logger,
	})

	consumer := workers.NewConsumerWC(workers.ConsumerDeps{
		Repo:        repo,
		KafkaClient: kafka,
		Logger:      logger,
	})

	notifyer := workers.NewNotifyer(workers.NotifyerDeps{
		Repo:           repo,
		MailClient:     mailClient,
		CustomerClient: customerClient,
		Logger:         logger,
	})

	welcomer := workers.NewWelcomer(workers.WelcomerDeps{
		Repo:        repo,
		MailClient:  mailClient,
		Logger:      logger,
		WelcomeChan: welcomeChan,
	})

	go consumer.Start(ctx)
	go welcomer.Start(ctx)
	go notifyer.Start(ctx)

	<-ctx.Done()

	return nil
}