refactor(issues): implemento carga perezosa del servicio de issues

Author: thomas-vilte

cmd/main.go

@@ -16,6 +16,7 @@ import (
 	"github.com/Tomas-vilte/MateCommit/internal/cli/command/update"
 	"github.com/Tomas-vilte/MateCommit/internal/cli/registry"
 	cfg "github.com/Tomas-vilte/MateCommit/internal/config"
+	"github.com/Tomas-vilte/MateCommit/internal/domain/ports"
 	"github.com/Tomas-vilte/MateCommit/internal/i18n"
 	"github.com/Tomas-vilte/MateCommit/internal/infrastructure/ai/gemini"
 	"github.com/Tomas-vilte/MateCommit/internal/infrastructure/di"
@@ -91,18 +92,17 @@ func initializeApp() (*cli.Command, error) {
 	prServiceFactory := factory.NewPrServiceFactory(cfgApp, translations, nil, gitService)
 	prCommand := pull_requests.NewSummarizeCommand(prServiceFactory)
 
-	issueGeneratorService, err := container.GetIssueGeneratorService(ctx)
-	if err != nil {
-		log.Printf("Warning: no se pudo inicializar el servicio de generación de issues: %v", err)
-	}
-
 	registerCommand := registry.NewRegistry(cfgApp, translations)
 
 	if err := registerCommand.Register("suggest", suggests_commits.NewSuggestCommandFactory(commitService, commitHandler)); err != nil {
 		log.Fatalf("Error al registrar el comando 'suggest': %v", err)
 	}
 
-	if err := registerCommand.Register("issue", issues.NewIssuesCommandFactory(issueGeneratorService, container.GetIssueTemplateService())); err != nil {
+	issueServiceProvider := func(ctx context.Context) (ports.IssueGeneratorService, error) {
+		return container.GetIssueGeneratorService(ctx)
+	}
+
+	if err := registerCommand.Register("issue", issues.NewIssuesCommandFactory(issueServiceProvider, container.GetIssueTemplateService())); err != nil {
 		log.Fatalf("Error al registrar el comando 'issue': %v", err)
 	}
 

internal/cli/command/issues/issues.go

@@ -17,17 +17,20 @@ import (
 	"github.com/urfave/cli/v3"
 )
 
+// IssueServiceProvider es una interfaz para obtener el servicio de issues de manera lazy
+type IssueServiceProvider func(ctx context.Context) (ports.IssueGeneratorService, error)
+
 // IssuesCommandFactory es el factory para crear el comando de issues.
 type IssuesCommandFactory struct {
-	issueService    ports.IssueGeneratorService
-	templateService ports.IssueTemplateService
+	issueServiceProvider IssueServiceProvider
+	templateService      ports.IssueTemplateService
 }
 
 // NewIssuesCommandFactory crea una nueva instancia del factory.
-func NewIssuesCommandFactory(issueService ports.IssueGeneratorService, templateService ports.IssueTemplateService) *IssuesCommandFactory {
+func NewIssuesCommandFactory(issueServiceProvider IssueServiceProvider, templateService ports.IssueTemplateService) *IssuesCommandFactory {
 	return &IssuesCommandFactory{
-		issueService:    issueService,
-		templateService: templateService,
+		issueServiceProvider: issueServiceProvider,
+		templateService:      templateService,
 	}
 }
 
@@ -141,6 +144,12 @@ func (f *IssuesCommandFactory) createGenerateAction(t *i18n.Translations, cfg *c
 
 		ui.PrintSectionBanner(t.GetMessage("issue.banner", 0, nil))
 
+		issueService, err := f.issueServiceProvider(ctx)
+		if err != nil {
+			ui.PrintError(fmt.Sprintf("%s: %v", t.GetMessage("issue.error_generating", 0, nil), err))
+			return err
+		}
+
 		var spinnerMsg string
 		if fromPR > 0 {
 			spinnerMsg = t.GetMessage("issue.analyzing_pr", 0, map[string]interface{}{
@@ -154,16 +163,15 @@ func (f *IssuesCommandFactory) createGenerateAction(t *i18n.Translations, cfg *c
 		spinner.Start()
 
 		var result *models.IssueGenerationResult
-		var err error
 
 		if templateName != "" {
-			result, err = f.issueService.GenerateWithTemplate(ctx, templateName, hint, fromDiff, description, noLabels)
+			result, err = issueService.GenerateWithTemplate(ctx, templateName, hint, fromDiff, description, noLabels)
 		} else if fromDiff {
-			result, err = f.issueService.GenerateFromDiff(ctx, hint, noLabels)
+			result, err = issueService.GenerateFromDiff(ctx, hint, noLabels)
 		} else if fromPR > 0 {
-			result, err = f.issueService.GenerateFromPR(ctx, fromPR, hint, noLabels)
+			result, err = issueService.GenerateFromPR(ctx, fromPR, hint, noLabels)
 		} else {
-			result, err = f.issueService.GenerateFromDescription(ctx, description, noLabels)
+			result, err = issueService.GenerateFromDescription(ctx, description, noLabels)
 		}
 
 		spinner.Stop()
@@ -191,7 +199,7 @@ func (f *IssuesCommandFactory) createGenerateAction(t *i18n.Translations, cfg *c
 			spinner = ui.NewSmartSpinner(t.GetMessage("issue.getting_user", 0, nil))
 			spinner.Start()
 
-			username, err := f.issueService.GetAuthenticatedUser(ctx)
+			username, err := issueService.GetAuthenticatedUser(ctx)
 			spinner.Stop()
 
 			if err != nil {
@@ -207,7 +215,7 @@ func (f *IssuesCommandFactory) createGenerateAction(t *i18n.Translations, cfg *c
 		spinner = ui.NewSmartSpinner(t.GetMessage("issue.creating", 0, nil))
 		spinner.Start()
 
-		issue, err := f.issueService.CreateIssue(ctx, result, assignees)
+		issue, err := issueService.CreateIssue(ctx, result, assignees)
 		spinner.Stop()
 
 		if err != nil {
@@ -221,7 +229,7 @@ func (f *IssuesCommandFactory) createGenerateAction(t *i18n.Translations, cfg *c
 		}))
 
 		if fromPR > 0 {
-			if err := f.issueService.LinkIssueToPR(ctx, fromPR, issue.Number); err != nil {
+			if err := issueService.LinkIssueToPR(ctx, fromPR, issue.Number); err != nil {
 				ui.PrintWarning(t.GetMessage("issue.link_error", 0, map[string]interface{}{
 					"PR":    fromPR,
 					"Error": err,
@@ -235,7 +243,7 @@ func (f *IssuesCommandFactory) createGenerateAction(t *i18n.Translations, cfg *c
 		}
 
 		if checkoutBranch {
-			branchName := f.issueService.InferBranchName(issue.Number, result.Labels)
+			branchName := issueService.InferBranchName(issue.Number, result.Labels)
 
 			ui.PrintInfo(t.GetMessage("issue.creating_branch", 0, map[string]interface{}{
 				"Branch": branchName,

internal/cli/command/issues/issues_test.go

@@ -7,20 +7,26 @@ import (
 
 	"github.com/Tomas-vilte/MateCommit/internal/config"
 	"github.com/Tomas-vilte/MateCommit/internal/domain/models"
+	"github.com/Tomas-vilte/MateCommit/internal/domain/ports"
 	"github.com/Tomas-vilte/MateCommit/internal/i18n"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/mock"
 	"github.com/stretchr/testify/require"
 	"github.com/urfave/cli/v3"
 )
 
-func setupIssuesTest(t *testing.T) (*MockIssueGeneratorService, *MockIssueTemplateService, *i18n.Translations, *config.Config) {
+func setupIssuesTest(t *testing.T) (*MockIssueGeneratorService, *MockIssueTemplateService, IssueServiceProvider, *i18n.Translations, *config.Config) {
 	mockGen := &MockIssueGeneratorService{}
 	mockTemp := &MockIssueTemplateService{}
+
+	provider := func(ctx context.Context) (ports.IssueGeneratorService, error) {
+		return mockGen, nil
+	}
+
 	trans, err := i18n.NewTranslations("en", "../../../../internal/i18n/locales")
 	require.NoError(t, err)
 	cfg := &config.Config{Language: "en"}
-	return mockGen, mockTemp, trans, cfg
+	return mockGen, mockTemp, provider, trans, cfg
 }
 
 func withStdin(input string, f func()) {
@@ -41,8 +47,8 @@ func withStdin(input string, f func()) {
 
 func TestIssueGenerateAction(t *testing.T) {
 	t.Run("should fail if no input provided", func(t *testing.T) {
-		mockGen, mockTemp, trans, cfg := setupIssuesTest(t)
-		factory := NewIssuesCommandFactory(mockGen, mockTemp)
+		_, mockTemp, provider, trans, cfg := setupIssuesTest(t)
+		factory := NewIssuesCommandFactory(provider, mockTemp)
 		cmd := factory.CreateCommand(trans, cfg)
 
 		app := &cli.Command{Name: "test", Commands: []*cli.Command{cmd}}
@@ -53,8 +59,8 @@ func TestIssueGenerateAction(t *testing.T) {
 	})
 
 	t.Run("should fail if multiple sources provided", func(t *testing.T) {
-		mockGen, mockTemp, trans, cfg := setupIssuesTest(t)
-		factory := NewIssuesCommandFactory(mockGen, mockTemp)
+		_, mockTemp, provider, trans, cfg := setupIssuesTest(t)
+		factory := NewIssuesCommandFactory(provider, mockTemp)
 		cmd := factory.CreateCommand(trans, cfg)
 
 		app := &cli.Command{Name: "test", Commands: []*cli.Command{cmd}}
@@ -65,8 +71,8 @@ func TestIssueGenerateAction(t *testing.T) {
 	})
 
 	t.Run("should generate from diff successfully", func(t *testing.T) {
-		mockGen, mockTemp, trans, cfg := setupIssuesTest(t)
-		factory := NewIssuesCommandFactory(mockGen, mockTemp)
+		mockGen, mockTemp, provider, trans, cfg := setupIssuesTest(t)
+		factory := NewIssuesCommandFactory(provider, mockTemp)
 		cmd := factory.CreateCommand(trans, cfg)
 
 		expectedResult := &models.IssueGenerationResult{
@@ -88,8 +94,8 @@ func TestIssueGenerateAction(t *testing.T) {
 	})
 
 	t.Run("should handle dry-run correctly", func(t *testing.T) {
-		mockGen, mockTemp, trans, cfg := setupIssuesTest(t)
-		factory := NewIssuesCommandFactory(mockGen, mockTemp)
+		mockGen, mockTemp, provider, trans, cfg := setupIssuesTest(t)
+		factory := NewIssuesCommandFactory(provider, mockTemp)
 		cmd := factory.CreateCommand(trans, cfg)
 
 		expectedResult := &models.IssueGenerationResult{
@@ -108,8 +114,8 @@ func TestIssueGenerateAction(t *testing.T) {
 	})
 
 	t.Run("should handle assign-me flag", func(t *testing.T) {
-		mockGen, mockTemp, trans, cfg := setupIssuesTest(t)
-		factory := NewIssuesCommandFactory(mockGen, mockTemp)
+		mockGen, mockTemp, provider, trans, cfg := setupIssuesTest(t)
+		factory := NewIssuesCommandFactory(provider, mockTemp)
 		cmd := factory.CreateCommand(trans, cfg)
 
 		expectedResult := &models.IssueGenerationResult{
@@ -130,8 +136,8 @@ func TestIssueGenerateAction(t *testing.T) {
 	})
 
 	t.Run("should cancel if user chooses no", func(t *testing.T) {
-		mockGen, mockTemp, trans, cfg := setupIssuesTest(t)
-		factory := NewIssuesCommandFactory(mockGen, mockTemp)
+		mockGen, mockTemp, provider, trans, cfg := setupIssuesTest(t)
+		factory := NewIssuesCommandFactory(provider, mockTemp)
 		cmd := factory.CreateCommand(trans, cfg)
 
 		mockGen.On("GenerateFromDiff", mock.Anything, "", false).Return(&models.IssueGenerationResult{Title: "T"}, nil)
@@ -146,8 +152,8 @@ func TestIssueGenerateAction(t *testing.T) {
 	})
 
 	t.Run("should use template if specified", func(t *testing.T) {
-		mockGen, mockTemp, trans, cfg := setupIssuesTest(t)
-		factory := NewIssuesCommandFactory(mockGen, mockTemp)
+		mockGen, mockTemp, provider, trans, cfg := setupIssuesTest(t)
+		factory := NewIssuesCommandFactory(provider, mockTemp)
 		cmd := factory.CreateCommand(trans, cfg)
 
 		expectedResult := &models.IssueGenerationResult{Title: "Template Issue"}

internal/cli/command/issues/templates_test.go

@@ -11,8 +11,8 @@ import (
 
 func TestIssueTemplateAction(t *testing.T) {
 	t.Run("should init templates successfully", func(t *testing.T) {
-		mockGen, mockTemp, trans, cfg := setupIssuesTest(t)
-		factory := NewIssuesCommandFactory(mockGen, mockTemp)
+		_, mockTemp, provider, trans, cfg := setupIssuesTest(t)
+		factory := NewIssuesCommandFactory(provider, mockTemp)
 		cmd := factory.CreateCommand(trans, cfg)
 
 		mockTemp.On("InitializeTemplates", false).Return(nil)
@@ -26,8 +26,8 @@ func TestIssueTemplateAction(t *testing.T) {
 	})
 
 	t.Run("should init templates with force flag", func(t *testing.T) {
-		mockGen, mockTemp, trans, cfg := setupIssuesTest(t)
-		factory := NewIssuesCommandFactory(mockGen, mockTemp)
+		_, mockTemp, provider, trans, cfg := setupIssuesTest(t)
+		factory := NewIssuesCommandFactory(provider, mockTemp)
 		cmd := factory.CreateCommand(trans, cfg)
 
 		mockTemp.On("InitializeTemplates", true).Return(nil)
@@ -41,8 +41,8 @@ func TestIssueTemplateAction(t *testing.T) {
 	})
 
 	t.Run("should list templates successfully", func(t *testing.T) {
-		mockGen, mockTemp, trans, cfg := setupIssuesTest(t)
-		factory := NewIssuesCommandFactory(mockGen, mockTemp)
+		_, mockTemp, provider, trans, cfg := setupIssuesTest(t)
+		factory := NewIssuesCommandFactory(provider, mockTemp)
 		cmd := factory.CreateCommand(trans, cfg)
 
 		templates := []models.TemplateMetadata{
@@ -59,8 +59,8 @@ func TestIssueTemplateAction(t *testing.T) {
 	})
 
 	t.Run("should handle empty template list", func(t *testing.T) {
-		mockGen, mockTemp, trans, cfg := setupIssuesTest(t)
-		factory := NewIssuesCommandFactory(mockGen, mockTemp)
+		_, mockTemp, provider, trans, cfg := setupIssuesTest(t)
+		factory := NewIssuesCommandFactory(provider, mockTemp)
 		cmd := factory.CreateCommand(trans, cfg)
 
 		mockTemp.On("ListTemplates").Return([]models.TemplateMetadata{}, nil)