cybertron/internal/dependencies/dependencies.go

package dependencies

import (
	"cybertron/configs"
	"cybertron/internal/client/aws"
	"cybertron/internal/client/document"
	"cybertron/internal/database"
	"cybertron/internal/transport/handler"
	"cybertron/pkg/db"
	httpclient "cybertron/pkg/httpClient"
	"cybertron/pkg/kafka/producer"
	"cybertron/pkg/log"
	"cybertron/service"
	"go.uber.org/zap"
	"gorm.io/gorm"
)

type Dependencies struct {
	Service      *Service
	DBClient     *gorm.DB
	Logger       *zap.Logger
	Handler      *Handler
	Repositories *Repositories
}

type Service struct {
	DocumentService  *document.HttpClient
	ProjectService   *service.ProjectCreator
	ReleaseService   *service.ReleaseService
	ExceptionService *service.ExceptionService
	S3Client        *aws.Actions
	// Add your service here
}

type Handler struct {
	ProjectHandler   *handler.ProjectHandler
	ReleaseHandler   *handler.ReleasesHandler
	ExceptionHandler *handler.ExceptionHandler
}

type Repositories struct {
	ProjectRepository *gorm.DB
	ReleaseRepository *gorm.DB
}

func InitDependencies() *Dependencies {
	dbClient := db.NewDBClient()
	repositories := initRepositories(dbClient)
	logger := log.Log
	httpClient := httpclient.NewHttpClient(*configs.GetHttpConfig())
	s3Client := aws.NewS3client(*configs.GetAWSConfig())
	kafkaProducer := initKafkaProducer()

	documentServiceClient := document.NewDocumentServiceHttpClient(httpClient, logger, configs.GetDocumentServiceHttpClientConfigs())
	projectServiceClient := service.NewProjectCreator(logger, dbClient, s3Client, kafkaProducer)
	releaseServiceClient := service.NewReleaseService(logger, dbClient)
	exceptionServiceClient := service.NewExceptionService(logger, dbClient, kafkaProducer)

	services := initServices(documentServiceClient, projectServiceClient, releaseServiceClient, exceptionServiceClient)
	handlers := initHandlers(projectServiceClient, releaseServiceClient, exceptionServiceClient)
	return &Dependencies{
		Service:      services,
		DBClient:     dbClient,
		Logger:       logger.GetLog(),
		Handler:      handlers,
		Repositories: repositories,
	}
}

func initServices(documentService *document.HttpClient, projectService *service.ProjectCreator, releaseService *service.ReleaseService, exceptionService *service.ExceptionService) *Service {
	return &Service{
		DocumentService:  documentService,
		ProjectService:   projectService,
		ReleaseService:   releaseService,
		ExceptionService: exceptionService,
	}
}

func initRepositories(dbClient *gorm.DB) *Repositories {
	return &Repositories{
		ProjectRepository: database.InitProjectRepository(dbClient),
		ReleaseRepository: database.InitReleaseRepository(dbClient),
	}
}

func initHandlers(projectService *service.ProjectCreator, releaseService *service.ReleaseService, exceotionService *service.ExceptionService) *Handler {
	projectHandler := handler.NewProjectHandler(projectService)
	releaseHandler := handler.NewReleaseHandler(releaseService)
	exceptionHandler := handler.NewExceptionHandler(exceotionService)
	return &Handler{
		ProjectHandler:   projectHandler,
		ReleaseHandler:   releaseHandler,
		ExceptionHandler: exceptionHandler,
	}
}

func initKafkaProducer() producer.KProducer {
	kafkaProducer := producer.NewKProducer(configs.GetEnv(), configs.GetKafkaConfig())
	return kafkaProducer
}