feat: use dig for controllers

internal/bootstrap/app_bootstrap.go

@@ -229,7 +229,7 @@ func (app *BootstrapApp) Setup() error {
 		Queries repository.Store
 	}
 
-	app.dig.Provide(func() utilityProvider {
+	err = app.dig.Provide(func() utilityProvider {
 		return utilityProvider{
 			Log:     app.log,
 			Config:  &app.config,
@@ -240,6 +240,10 @@ func (app *BootstrapApp) Setup() error {
 		}
 	})
 
+	if err != nil {
+		return fmt.Errorf("failed to provide utilities to container: %w", err)
+	}
+
 	// services
 	err = app.setupServices()
 

internal/bootstrap/router_bootstrap.go

@@ -13,6 +13,7 @@ import (
 	"github.com/tinyauthapp/tinyauth/internal/controller"
 	"github.com/tinyauthapp/tinyauth/internal/middleware"
 	"github.com/tinyauthapp/tinyauth/internal/model"
+	"go.uber.org/dig"
 
 	"github.com/gin-gonic/gin"
 )
@@ -40,31 +41,119 @@ func (app *BootstrapApp) setupRouter() error {
 		}
 	}
 
-	contextMiddleware := middleware.NewContextMiddleware(app.log, app.runtime, app.services.authService, app.services.oauthBrokerService, app.services.tailscaleService)
-	engine.Use(contextMiddleware.Middleware())
-
-	uiMiddleware, err := middleware.NewUIMiddleware()
+	err := app.dig.Provide(middleware.NewContextMiddleware)
 
 	if err != nil {
-		return fmt.Errorf("failed to initialize UI middleware: %w", err)
+		return fmt.Errorf("failed to provide context middleware: %w", err)
 	}
 
-	engine.Use(uiMiddleware.Middleware())
+	err = app.dig.Provide(middleware.NewUIMiddleware)
 
-	zerologMiddleware := middleware.NewZerologMiddleware(app.log)
+	if err != nil {
+		return fmt.Errorf("failed to provide ui middleware: %w", err)
+	}
 
-	engine.Use(zerologMiddleware.Middleware())
+	err = app.dig.Provide(middleware.NewZerologMiddleware)
 
-	apiRouter := engine.Group("/api")
+	if err != nil {
+		return fmt.Errorf("failed to provide zerolog middleware: %w", err)
+	}
 
-	controller.NewContextController(app.log, app.config, app.runtime, apiRouter)
-	controller.NewOAuthController(app.log, app.config, app.runtime, apiRouter, app.services.authService)
-	controller.NewOIDCController(app.log, app.services.oidcService, app.runtime, apiRouter, &engine.RouterGroup)
-	controller.NewProxyController(app.log, app.runtime, apiRouter, app.services.accessControlService, app.services.authService, app.services.policyEngine)
-	controller.NewUserController(app.log, app.runtime, apiRouter, app.services.authService)
-	controller.NewResourcesController(app.config, &engine.RouterGroup)
-	controller.NewHealthController(apiRouter)
-	controller.NewWellKnownController(app.services.oidcService, &engine.RouterGroup)
+	type middlewareInput struct {
+		dig.In
+
+		ContextMiddleware *middleware.ContextMiddleware
+		UIMiddleware      *middleware.UIMiddleware
+		ZerologMiddleware *middleware.ZerologMiddleware
+	}
+
+	err = app.dig.Invoke(func(mi middlewareInput) {
+		engine.Use(mi.ContextMiddleware.Middleware())
+		engine.Use(mi.UIMiddleware.Middleware())
+		engine.Use(mi.ZerologMiddleware.Middleware())
+	})
+
+	if err != nil {
+		return fmt.Errorf("failed to invoke middleware: %w", err)
+	}
+
+	err = app.dig.Provide(func() *gin.RouterGroup {
+		return &engine.RouterGroup
+	}, dig.Name("mainRouterGroup"))
+
+	if err != nil {
+		return fmt.Errorf("failed to provide main router group: %w", err)
+	}
+
+	err = app.dig.Provide(func() *gin.RouterGroup {
+		return engine.Group("/api")
+	}, dig.Name("apiRouterGroup"))
+
+	if err != nil {
+		return fmt.Errorf("failed to provide api router group: %w", err)
+	}
+
+	err = app.dig.Provide(controller.NewContextController)
+	if err != nil {
+		return fmt.Errorf("failed to provide context controller: %w", err)
+	}
+
+	err = app.dig.Provide(controller.NewOAuthController)
+	if err != nil {
+		return fmt.Errorf("failed to provide oauth controller: %w", err)
+	}
+
+	err = app.dig.Provide(controller.NewOIDCController)
+	if err != nil {
+		return fmt.Errorf("failed to provide oidc controller: %w", err)
+	}
+
+	err = app.dig.Provide(controller.NewProxyController)
+	if err != nil {
+		return fmt.Errorf("failed to provide proxy controller: %w", err)
+	}
+
+	err = app.dig.Provide(controller.NewUserController)
+	if err != nil {
+		return fmt.Errorf("failed to provide user controller: %w", err)
+	}
+
+	err = app.dig.Provide(controller.NewResourcesController)
+	if err != nil {
+		return fmt.Errorf("failed to provide resources controller: %w", err)
+	}
+
+	err = app.dig.Provide(controller.NewHealthController)
+	if err != nil {
+		return fmt.Errorf("failed to provide health controller: %w", err)
+	}
+
+	err = app.dig.Provide(controller.NewWellKnownController)
+	if err != nil {
+		return fmt.Errorf("failed to provide well-known controller: %w", err)
+	}
+
+	type controllerInput struct {
+		dig.In
+
+		ContextController   *controller.ContextController
+		OAuthController     *controller.OAuthController
+		OIDCController      *controller.OIDCController
+		ProxyController     *controller.ProxyController
+		UserController      *controller.UserController
+		ResourcesController *controller.ResourcesController
+		HealthController    *controller.HealthController
+		WellKnownController *controller.WellKnownController
+	}
+
+	// force dig to build all controllers and register their routes
+	err = app.dig.Invoke(func(ci controllerInput) error {
+		return nil
+	})
+
+	if err != nil {
+		return fmt.Errorf("failed to invoke controllers: %w", err)
+	}
 
 	app.router = engine
 	return nil

internal/bootstrap/service_bootstrap.go

@@ -9,19 +9,46 @@ import (
 )
 
 func (app *BootstrapApp) setupServices() error {
-	app.setupPolicyEngine()
+	err := app.setupPolicyEngine()
 
-	app.dig.Provide(func() *service.PolicyEngine {
-		return app.services.policyEngine
-	})
+	if err != nil {
+		return fmt.Errorf("failed to setup policy engine: %w", err)
+	}
 
-	app.dig.Provide(app.getLabelProvider)
-	app.dig.Provide(service.NewLdapService)
-	app.dig.Provide(service.NewTailscaleService)
-	app.dig.Provide(service.NewAccessControlsService)
-	app.dig.Provide(service.NewOAuthBrokerService)
-	app.dig.Provide(service.NewAuthService)
-	app.dig.Provide(service.NewOIDCService)
+	err = app.dig.Provide(app.getLabelProvider)
+	if err != nil {
+		return fmt.Errorf("failed to provide label provider: %w", err)
+	}
+
+	err = app.dig.Provide(service.NewLdapService)
+	if err != nil {
+		return fmt.Errorf("failed to provide ldap service: %w", err)
+	}
+
+	err = app.dig.Provide(service.NewTailscaleService)
+	if err != nil {
+		return fmt.Errorf("failed to provide tailscale service: %w", err)
+	}
+
+	err = app.dig.Provide(service.NewAccessControlsService)
+	if err != nil {
+		return fmt.Errorf("failed to provide access controls service: %w", err)
+	}
+
+	err = app.dig.Provide(service.NewOAuthBrokerService)
+	if err != nil {
+		return fmt.Errorf("failed to provide oauth broker service: %w", err)
+	}
+
+	err = app.dig.Provide(service.NewAuthService)
+	if err != nil {
+		return fmt.Errorf("failed to provide auth service: %w", err)
+	}
+
+	err = app.dig.Provide(service.NewOIDCService)
+	if err != nil {
+		return fmt.Errorf("failed to provide oidc service: %w", err)
+	}
 
 	type svcInput struct {
 		dig.In
@@ -34,7 +61,7 @@ func (app *BootstrapApp) setupServices() error {
 		TailscaleService     *service.TailscaleService
 	}
 
-	err := app.dig.Invoke(func(i svcInput) error {
+	err = app.dig.Invoke(func(i svcInput) error {
 		app.services = Services{
 			accessControlService: i.AccessControlService,
 			authService:          i.AuthService,
@@ -45,7 +72,11 @@ func (app *BootstrapApp) setupServices() error {
 		return nil
 	})
 
-	return err
+	if err != nil {
+		return fmt.Errorf("failed to invoke services: %w", err)
+	}
+
+	return nil
 }
 
 func (app *BootstrapApp) getLabelProvider() (service.LabelProvider, error) {
@@ -61,25 +92,41 @@ func (app *BootstrapApp) getLabelProvider() (service.LabelProvider, error) {
 		if useKubernetes {
 			app.log.App.Debug().Msg("Using Kubernetes label provider")
 
-			app.dig.Provide(service.NewKubernetesService)
+			err := app.dig.Provide(service.NewKubernetesService)
 
-			app.dig.Invoke(func(k *service.KubernetesService) error {
+			if err != nil {
+				return nil, fmt.Errorf("failed to provide kubernetes service: %w", err)
+			}
+
+			err = app.dig.Invoke(func(k *service.KubernetesService) error {
 				app.services.kubernetesService = k
 				return nil
 			})
 
+			if err != nil {
+				return nil, fmt.Errorf("failed to invoke kubernetes service: %w", err)
+			}
+
 			return app.services.kubernetesService, nil
 		}
 
 		app.log.App.Debug().Msg("Using Docker label provider")
 
-		app.dig.Provide(service.NewDockerService)
+		err := app.dig.Provide(service.NewDockerService)
 
-		app.dig.Invoke(func(d *service.DockerService) error {
+		if err != nil {
+			return nil, fmt.Errorf("failed to provide docker service: %w", err)
+		}
+
+		err = app.dig.Invoke(func(d *service.DockerService) error {
 			app.services.dockerService = d
 			return nil
 		})
 
+		if err != nil {
+			return nil, fmt.Errorf("failed to invoke docker service: %w", err)
+		}
+
 		if app.services.dockerService == nil {
 			if app.config.LabelProvider == "docker" {
 				app.log.App.Warn().Msg("Docker label provider selected but Docker is not available, will continue without it")
@@ -93,10 +140,14 @@ func (app *BootstrapApp) getLabelProvider() (service.LabelProvider, error) {
 	}
 }
 
-func (app *BootstrapApp) setupPolicyEngine() {
-	app.dig.Provide(service.NewPolicyEngine)
+func (app *BootstrapApp) setupPolicyEngine() error {
+	err := app.dig.Provide(service.NewPolicyEngine)
 
-	app.dig.Invoke(func(policyEngine *service.PolicyEngine) error {
+	if err != nil {
+		return fmt.Errorf("failed to create policy engine: %w", err)
+	}
+
+	err = app.dig.Invoke(func(policyEngine *service.PolicyEngine) error {
 		policyEngine.RegisterRule(service.RuleUserAllowed, &service.UserAllowedRule{
 			Log: app.log,
 		})
@@ -119,4 +170,6 @@ func (app *BootstrapApp) setupPolicyEngine() {
 		})
 		return nil
 	})
+
+	return err
 }