Remove UsecaseDependancies service locator pattern

Replace the UsecaseDependancies interface with plain Dependencies structs
defined locally in each route package. DeclareRoutes acts as the sole
composition root where use cases are resolved; sub-route functions and
controllers receive only the specific interfaces they need.

internal/api-admin/route/auth_user.go

@@ -26,11 +26,10 @@ import (
 
 	"git.happydns.org/happyDomain/internal/api-admin/controller"
 	"git.happydns.org/happyDomain/internal/storage"
-	"git.happydns.org/happyDomain/model"
 )
 
-func declareUserAuthsRoutes(router *gin.RouterGroup, dependancies happydns.UsecaseDependancies, store storage.Storage) {
+func declareUserAuthsRoutes(router *gin.RouterGroup, dep Dependencies, store storage.Storage) {
-	ac := controller.NewAuthUserController(dependancies.AuthUserUsecase(), store)
+	ac := controller.NewAuthUserController(dep.AuthUser, store)
 
 	router.GET("/auth", ac.GetAuthUsers)
 	router.POST("/auth", ac.NewAuthUser)

internal/api-admin/route/domain.go

@@ -27,14 +27,13 @@ import (
 	"git.happydns.org/happyDomain/internal/api-admin/controller"
 	"git.happydns.org/happyDomain/internal/api/middleware"
 	"git.happydns.org/happyDomain/internal/storage"
-	"git.happydns.org/happyDomain/model"
 )
 
-func declareDomainRoutes(router *gin.RouterGroup, dependancies happydns.UsecaseDependancies, store storage.Storage) {
+func declareDomainRoutes(router *gin.RouterGroup, dep Dependencies, store storage.Storage) {
 	dc := controller.NewDomainController(
-		dependancies.DomainUsecase(),
+		dep.Domain,
-		dependancies.RemoteZoneImporterUsecase(),
+		dep.RemoteZoneImporter,
-		dependancies.ZoneImporterUsecase(),
+		dep.ZoneImporter,
 		store,
 	)
 
@@ -45,11 +44,11 @@ func declareDomainRoutes(router *gin.RouterGroup, dependancies happydns.UsecaseD
 	router.DELETE("/domains/:domain", dc.DeleteDomain)
 
 	apiDomainsRoutes := router.Group("/domains/:domain")
-	apiDomainsRoutes.Use(middleware.DomainHandler(dependancies.DomainUsecase(), true))
+	apiDomainsRoutes.Use(middleware.DomainHandler(dep.Domain, true))
 
 	apiDomainsRoutes.GET("", dc.GetDomain)
 	apiDomainsRoutes.PUT("", dc.UpdateDomain)
 
 	apiDomainsRoutes.PUT("/zones", dc.UpdateZones)
-	declareZoneRoutes(apiDomainsRoutes, dependancies, store)
+	declareZoneRoutes(apiDomainsRoutes, dep, store)
 }

internal/api-admin/route/provider.go

@@ -27,26 +27,25 @@ import (
 	"git.happydns.org/happyDomain/internal/api-admin/controller"
 	"git.happydns.org/happyDomain/internal/api/middleware"
 	"git.happydns.org/happyDomain/internal/storage"
-	"git.happydns.org/happyDomain/model"
 )
 
-func declareProviderRoutes(router *gin.RouterGroup, dependancies happydns.UsecaseDependancies, store storage.Storage) {
+func declareProviderRoutes(router *gin.RouterGroup, dep Dependencies, store storage.Storage) {
-	pc := controller.NewProviderController(dependancies.ProviderUsecase(false), store)
+	pc := controller.NewProviderController(dep.Provider, store)
 
 	router.GET("/providers", pc.ListProviders)
 	router.POST("/providers", pc.AddProvider)
 	router.DELETE("/providers", pc.ClearProviders)
 
 	apiProvidersMetaRoutes := router.Group("/providers/:pid")
-	apiProvidersMetaRoutes.Use(middleware.ProviderMetaHandler(dependancies.ProviderUsecase(false)))
+	apiProvidersMetaRoutes.Use(middleware.ProviderMetaHandler(dep.Provider))
 
 	apiProvidersMetaRoutes.DELETE("", pc.DeleteProvider)
 
 	apiProvidersRoutes := router.Group("/providers/:pid")
-	apiProvidersRoutes.Use(middleware.ProviderHandler(dependancies.ProviderUsecase(false)))
+	apiProvidersRoutes.Use(middleware.ProviderHandler(dep.Provider))
 
 	apiProvidersRoutes.GET("", pc.GetProvider)
 	apiProvidersRoutes.PUT("", pc.UpdateProvider)
 
-	declareDomainRoutes(apiProvidersRoutes, dependancies, store)
+	declareDomainRoutes(apiProvidersRoutes, dep, store)
 }

internal/api-admin/route/route.go

@@ -26,18 +26,32 @@ import (
 
 	api "git.happydns.org/happyDomain/internal/api/route"
 	"git.happydns.org/happyDomain/internal/storage"
-	"git.happydns.org/happyDomain/model"
+	happydns "git.happydns.org/happyDomain/model"
 )
 
-func DeclareRoutes(cfg *happydns.Options, router *gin.Engine, s storage.Storage, dependancies happydns.UsecaseDependancies) {
+// Dependencies holds all use cases required to register the admin API routes.
+type Dependencies struct {
+	AuthUser              happydns.AuthUserUsecase
+	Domain                happydns.DomainUsecase
+	Provider              happydns.ProviderUsecase
+	RemoteZoneImporter    happydns.RemoteZoneImporterUsecase
+	Service               happydns.ServiceUsecase
+	User                  happydns.UserUsecase
+	Zone                  happydns.ZoneUsecase
+	ZoneCorrectionApplier happydns.ZoneCorrectionApplierUsecase
+	ZoneImporter          happydns.ZoneImporterUsecase
+	ZoneService           happydns.ZoneServiceUsecase
+}
+
+func DeclareRoutes(cfg *happydns.Options, router *gin.Engine, s storage.Storage, dep Dependencies) {
 	apiRoutes := router.Group("/api")
 
 	declareBackupRoutes(cfg, apiRoutes, s)
-	declareDomainRoutes(apiRoutes, dependancies, s)
+	declareDomainRoutes(apiRoutes, dep, s)
-	declareProviderRoutes(apiRoutes, dependancies, s)
+	declareProviderRoutes(apiRoutes, dep, s)
 	declareSessionsRoutes(cfg, apiRoutes, s)
-	declareUserAuthsRoutes(apiRoutes, dependancies, s)
+	declareUserAuthsRoutes(apiRoutes, dep, s)
-	declareUsersRoutes(apiRoutes, dependancies, s)
+	declareUsersRoutes(apiRoutes, dep, s)
 	declareTidyRoutes(apiRoutes, s)
 	api.DeclareVersionRoutes(apiRoutes)
 }

internal/api-admin/route/services.go

@@ -27,17 +27,16 @@ import (
 	"git.happydns.org/happyDomain/internal/api-admin/controller"
 	"git.happydns.org/happyDomain/internal/api/middleware"
 	"git.happydns.org/happyDomain/internal/storage"
-	"git.happydns.org/happyDomain/model"
 )
 
-func declareZoneServiceRoutes(apiZonesRoutes *gin.RouterGroup, zc *controller.ZoneController, dependancies happydns.UsecaseDependancies, store storage.Storage) {
+func declareZoneServiceRoutes(apiZonesRoutes *gin.RouterGroup, zc *controller.ZoneController, dep Dependencies, store storage.Storage) {
 	sc := controller.NewServiceController(
-		dependancies.ServiceUsecase(),
+		dep.Service,
-		dependancies.ZoneServiceUsecase(),
+		dep.ZoneService,
 	)
 
 	apiZonesServiceIdRoutes := apiZonesRoutes.Group("/services/:serviceid")
-	apiZonesServiceIdRoutes.Use(middleware.ServiceIdHandler(dependancies.ServiceUsecase()))
+	apiZonesServiceIdRoutes.Use(middleware.ServiceIdHandler(dep.Service))
 	apiZonesServiceIdRoutes.GET("", sc.GetZoneService)
 	apiZonesServiceIdRoutes.PUT("", sc.UpdateZoneService)
 	apiZonesServiceIdRoutes.DELETE("", sc.DeleteZoneService)

internal/api-admin/route/user.go

@@ -26,11 +26,10 @@ import (
 
 	"git.happydns.org/happyDomain/internal/api-admin/controller"
 	"git.happydns.org/happyDomain/internal/storage"
-	"git.happydns.org/happyDomain/model"
 )
 
-func declareUsersRoutes(router *gin.RouterGroup, dependancies happydns.UsecaseDependancies, store storage.Storage) {
+func declareUsersRoutes(router *gin.RouterGroup, dep Dependencies, store storage.Storage) {
-	sc := controller.NewUserController(store, dependancies.UserUsecase())
+	sc := controller.NewUserController(store, dep.User)
 
 	router.GET("/users", sc.GetUsers)
 	router.POST("/users", sc.NewUser)
@@ -43,6 +42,6 @@ func declareUsersRoutes(router *gin.RouterGroup, dependancies happydns.UsecaseDe
 	apiUsersRoutes.PUT("", sc.UpdateUser)
 	apiUsersRoutes.DELETE("", sc.DeleteUser)
 
-	declareDomainRoutes(apiUsersRoutes, dependancies, store)
+	declareDomainRoutes(apiUsersRoutes, dep, store)
-	declareProviderRoutes(apiUsersRoutes, dependancies, store)
+	declareProviderRoutes(apiUsersRoutes, dep, store)
 }

internal/api-admin/route/zone.go

@@ -27,14 +27,13 @@ import (
 	"git.happydns.org/happyDomain/internal/api-admin/controller"
 	"git.happydns.org/happyDomain/internal/api/middleware"
 	"git.happydns.org/happyDomain/internal/storage"
-	"git.happydns.org/happyDomain/model"
 )
 
-func declareZoneRoutes(router *gin.RouterGroup, dependancies happydns.UsecaseDependancies, store storage.Storage) {
+func declareZoneRoutes(router *gin.RouterGroup, dep Dependencies, store storage.Storage) {
 	zc := controller.NewZoneController(
-		dependancies.DomainUsecase(),
+		dep.Domain,
-		dependancies.ZoneUsecase(),
+		dep.Zone,
-		dependancies.ZoneCorrectionApplierUsecase(),
+		dep.ZoneCorrectionApplier,
 		store,
 	)
 
@@ -45,10 +44,10 @@ func declareZoneRoutes(router *gin.RouterGroup, dependancies happydns.UsecaseDep
 	router.DELETE("/zones/:zoneid", zc.DeleteZone)
 
 	apiZonesRoutes := router.Group("/zones/:zoneid")
-	apiZonesRoutes.Use(middleware.ZoneHandler(dependancies.ZoneUsecase()))
+	apiZonesRoutes.Use(middleware.ZoneHandler(dep.Zone))
 
 	apiZonesRoutes.GET("", zc.GetZone)
 	apiZonesRoutes.PUT("", zc.UpdateZone)
 
-	declareZoneServiceRoutes(apiZonesRoutes, zc, dependancies, store)
+	declareZoneServiceRoutes(apiZonesRoutes, zc, dep, store)
 }

internal/api/route/auth_user.go

@@ -31,11 +31,11 @@ import (
 	"git.happydns.org/happyDomain/model"
 )
 
-func DeclareAuthUserRoutes(router *gin.RouterGroup, dependancies happydns.UsecaseDependancies, lc *controller.LoginController) *controller.AuthUserController {
+func DeclareAuthUserRoutes(router *gin.RouterGroup, authUserUC happydns.AuthUserUsecase, lc *controller.LoginController) *controller.AuthUserController {
-	ac := controller.NewAuthUserController(dependancies.AuthUserUsecase(), lc)
+	ac := controller.NewAuthUserController(authUserUC, lc)
 
 	apiUserAuthRoutes := router.Group("/users/:uid")
-	apiUserAuthRoutes.Use(middleware.AuthUserHandler(dependancies.AuthUserUsecase()))
+	apiUserAuthRoutes.Use(middleware.AuthUserHandler(authUserUC))
 	apiUserAuthRoutes.GET("/is_auth_user", func(c *gin.Context) {
 		c.Status(http.StatusNoContent)
 	})

internal/api/route/authentication.go

@@ -32,13 +32,13 @@ import (
 	"git.happydns.org/happyDomain/model"
 )
 
-func DeclareAuthenticationRoutes(cfg *happydns.Options, baserouter, apirouter *gin.RouterGroup, dependancies happydns.UsecaseDependancies) *controller.LoginController {
+func DeclareAuthenticationRoutes(cfg *happydns.Options, baserouter, apirouter *gin.RouterGroup, authUC happydns.AuthenticationUsecase, captchaVerifier happydns.CaptchaVerifier, failureTracker happydns.FailureTracker) *controller.LoginController {
-	lc := controller.NewLoginController(dependancies.AuthenticationUsecase(), dependancies.CaptchaVerifier(), dependancies.FailureTracker())
+	lc := controller.NewLoginController(authUC, captchaVerifier, failureTracker)
 
 	apirouter.POST("/auth", lc.Login)
 	apirouter.POST("/auth/logout", lc.Logout)
 
-	if localChallenge, ok := dependancies.CaptchaVerifier().(happydns.CaptchaLocalChallenge); ok {
+	if localChallenge, ok := captchaVerifier.(happydns.CaptchaLocalChallenge); ok {
 		apirouter.GET("/auth/challenge", func(c *gin.Context) {
 			challenge, err := localChallenge.NewChallenge()
 			if err != nil {
@@ -50,7 +50,7 @@ func DeclareAuthenticationRoutes(cfg *happydns.Options, baserouter, apirouter *g
 	}
 
 	if len(cfg.OIDCClients) > 0 {
-		oidcp := controller.NewOIDCProvider(cfg, dependancies.AuthenticationUsecase())
+		oidcp := controller.NewOIDCProvider(cfg, authUC)
 
 		authRoutes := baserouter.Group("/auth")
 
@@ -71,6 +71,6 @@ func DeclareAuthenticationRoutes(cfg *happydns.Options, baserouter, apirouter *g
 	return lc
 }
 
-func DeclareAuthenticationCheckRoutes(apiAuthRoutes *gin.RouterGroup, dependancies happydns.UsecaseDependancies, lc *controller.LoginController) {
+func DeclareAuthenticationCheckRoutes(apiAuthRoutes *gin.RouterGroup, lc *controller.LoginController) {
 	apiAuthRoutes.GET("/auth", lc.GetLoggedUser)
 }

internal/api/route/domain.go

@@ -29,27 +29,27 @@ import (
 	"git.happydns.org/happyDomain/model"
 )
 
-func DeclareDomainRoutes(router *gin.RouterGroup, dependancies happydns.UsecaseDependancies) {
+func DeclareDomainRoutes(router *gin.RouterGroup, domainUC happydns.DomainUsecase, domainLogUC happydns.DomainLogUsecase, remoteZoneImporter happydns.RemoteZoneImporterUsecase, zoneImporter happydns.ZoneImporterUsecase, zoneUC happydns.ZoneUsecase, zoneCorrApplier happydns.ZoneCorrectionApplierUsecase, zoneServiceUC happydns.ZoneServiceUsecase, serviceUC happydns.ServiceUsecase) {
 	dc := controller.NewDomainController(
-		dependancies.DomainUsecase(),
+		domainUC,
-		dependancies.RemoteZoneImporterUsecase(),
+		remoteZoneImporter,
-		dependancies.ZoneImporterUsecase(),
+		zoneImporter,
 	)
 
 	router.GET("/domains", dc.GetDomains)
 	router.POST("/domains", dc.AddDomain)
 
 	apiDomainsRoutes := router.Group("/domains/:domain")
-	apiDomainsRoutes.Use(middleware.DomainHandler(dependancies.DomainUsecase(), false))
+	apiDomainsRoutes.Use(middleware.DomainHandler(domainUC, false))
 
 	apiDomainsRoutes.GET("", dc.GetDomain)
 	apiDomainsRoutes.PUT("", dc.UpdateDomain)
 	apiDomainsRoutes.DELETE("", dc.DelDomain)
 
-	DeclareDomainLogRoutes(apiDomainsRoutes, dependancies)
+	DeclareDomainLogRoutes(apiDomainsRoutes, domainLogUC)
 
 	apiDomainsRoutes.POST("/zone", dc.ImportZone)
 	apiDomainsRoutes.POST("/retrieve_zone", dc.RetrieveZone)
 
-	DeclareZoneRoutes(apiDomainsRoutes, dependancies)
+	DeclareZoneRoutes(apiDomainsRoutes, zoneUC, domainUC, zoneCorrApplier, zoneServiceUC, serviceUC)
 }

internal/api/route/domain_log.go

@@ -28,8 +28,8 @@ import (
 	"git.happydns.org/happyDomain/model"
 )
 
-func DeclareDomainLogRoutes(router *gin.RouterGroup, dependancies happydns.UsecaseDependancies) {
+func DeclareDomainLogRoutes(router *gin.RouterGroup, domainLogUC happydns.DomainLogUsecase) {
-	dlc := controller.NewDomainLogController(dependancies.DomainLogUsecase())
+	dlc := controller.NewDomainLogController(domainLogUC)
 
 	router.GET("/logs", dlc.GetDomainLogs)
 }

internal/api/route/provider.go

@@ -29,19 +29,19 @@ import (
 	"git.happydns.org/happyDomain/model"
 )
 
-func DeclareProviderRoutes(router *gin.RouterGroup, dependancies happydns.UsecaseDependancies) {
+func DeclareProviderRoutes(router *gin.RouterGroup, providerUC happydns.ProviderUsecase) {
-	pc := controller.NewProviderController(dependancies.ProviderUsecase(true))
+	pc := controller.NewProviderController(providerUC)
 
 	router.GET("/providers", pc.ListProviders)
 	router.POST("/providers", pc.AddProvider)
 
 	apiProvidersMetaRoutes := router.Group("/providers/:pid")
-	apiProvidersMetaRoutes.Use(middleware.ProviderMetaHandler(dependancies.ProviderUsecase(true)))
+	apiProvidersMetaRoutes.Use(middleware.ProviderMetaHandler(providerUC))
 
 	apiProvidersMetaRoutes.DELETE("", pc.DeleteProvider)
 
 	apiProviderRoutes := router.Group("/providers/:pid")
-	apiProviderRoutes.Use(middleware.ProviderHandler(dependancies.ProviderUsecase(true)))
+	apiProviderRoutes.Use(middleware.ProviderHandler(providerUC))
 
 	apiProviderRoutes.GET("", pc.GetProvider)
 	apiProviderRoutes.PUT("", pc.UpdateProvider)

internal/api/route/provider_settings.go

@@ -29,8 +29,8 @@ import (
 	"git.happydns.org/happyDomain/model"
 )
 
-func DeclareProviderSettingsRoutes(router *gin.RouterGroup, dependancies happydns.UsecaseDependancies) {
+func DeclareProviderSettingsRoutes(router *gin.RouterGroup, providerSettingsUC happydns.ProviderSettingsUsecase) {
-	psc := controller.NewProviderSettingsController(dependancies.ProviderSettingsUsecase())
+	psc := controller.NewProviderSettingsController(providerSettingsUC)
 
 	apiProviderSpecsRoutes := router.Group("/providers/_specs/:psid")
 	apiProviderSpecsRoutes.Use(middleware.ProviderSpecsHandler)

internal/api/route/provider_specs.go

@@ -28,8 +28,8 @@ import (
 	"git.happydns.org/happyDomain/model"
 )
 
-func DeclareProviderSpecsRoutes(router *gin.RouterGroup, dependancies happydns.UsecaseDependancies) {
+func DeclareProviderSpecsRoutes(router *gin.RouterGroup, providerSpecsUC happydns.ProviderSpecsUsecase) {
-	pc := controller.NewProviderSpecsController(dependancies.ProviderSpecsUsecase())
+	pc := controller.NewProviderSpecsController(providerSpecsUC)
 
 	router.GET("/providers/_specs", pc.ListProviders)
 

internal/api/route/record.go

@@ -25,10 +25,9 @@ import (
 	"github.com/gin-gonic/gin"
 
 	"git.happydns.org/happyDomain/internal/api/controller"
-	"git.happydns.org/happyDomain/model"
 )
 
-func DeclareRecordRoutes(apiRoutes *gin.RouterGroup, dependancies happydns.UsecaseDependancies) {
+func DeclareRecordRoutes(apiRoutes *gin.RouterGroup) {
 	rc := controller.NewRecordController()
 
 	apiRoutes.POST("/records", rc.ParseRecords)

internal/api/route/resolver.go

@@ -28,8 +28,8 @@ import (
 	"git.happydns.org/happyDomain/model"
 )
 
-func DeclareResolverRoutes(router *gin.RouterGroup, dependancies happydns.UsecaseDependancies) {
+func DeclareResolverRoutes(router *gin.RouterGroup, resolverUC happydns.ResolverUsecase) {
-	rc := controller.NewResolverController(dependancies.ResolverUsecase())
+	rc := controller.NewResolverController(resolverUC)
 
 	router.POST("/resolver", rc.RunResolver)
 }

internal/api/route/route.go

@@ -25,9 +25,33 @@ import (
 	"github.com/gin-gonic/gin"
 
 	"git.happydns.org/happyDomain/internal/api/middleware"
-	"git.happydns.org/happyDomain/model"
+	happydns "git.happydns.org/happyDomain/model"
 )
 
+// Dependencies holds all use cases required to register the public API routes.
+// It is a plain struct — no methods, no interface — constructed once in app.go.
+type Dependencies struct {
+	Authentication        happydns.AuthenticationUsecase
+	AuthUser              happydns.AuthUserUsecase
+	CaptchaVerifier       happydns.CaptchaVerifier
+	Domain                happydns.DomainUsecase
+	DomainLog             happydns.DomainLogUsecase
+	FailureTracker        happydns.FailureTracker
+	Provider              happydns.ProviderUsecase
+	ProviderSettings      happydns.ProviderSettingsUsecase
+	ProviderSpecs         happydns.ProviderSpecsUsecase
+	RemoteZoneImporter    happydns.RemoteZoneImporterUsecase
+	Resolver              happydns.ResolverUsecase
+	Service               happydns.ServiceUsecase
+	ServiceSpecs          happydns.ServiceSpecsUsecase
+	Session               happydns.SessionUsecase
+	User                  happydns.UserUsecase
+	Zone                  happydns.ZoneUsecase
+	ZoneCorrectionApplier happydns.ZoneCorrectionApplierUsecase
+	ZoneImporter          happydns.ZoneImporterUsecase
+	ZoneService           happydns.ZoneServiceUsecase
+}
+
 //	@title			happyDomain API
 //	@version		0.1
 //	@description	Finally a simple interface for domain names.
@@ -48,38 +72,37 @@ import (
 //	@name						Authorization
 //	@description				Description for what is this security definition being used
 
-func DeclareRoutes(cfg *happydns.Options, router *gin.Engine, dependancies happydns.UsecaseDependancies) {
+func DeclareRoutes(cfg *happydns.Options, router *gin.Engine, dep Dependencies) {
-	// Declare routes
 	baseRoutes := router.Group("")
 
 	declareRouteSwagger(cfg, baseRoutes)
 
 	apiRoutes := router.Group("/api")
 
-	lc := DeclareAuthenticationRoutes(cfg, baseRoutes, apiRoutes, dependancies)
+	lc := DeclareAuthenticationRoutes(cfg, baseRoutes, apiRoutes, dep.Authentication, dep.CaptchaVerifier, dep.FailureTracker)
-	auc := DeclareAuthUserRoutes(apiRoutes, dependancies, lc)
+	auc := DeclareAuthUserRoutes(apiRoutes, dep.AuthUser, lc)
-	DeclareProviderSpecsRoutes(apiRoutes, dependancies)
+	DeclareProviderSpecsRoutes(apiRoutes, dep.ProviderSpecs)
-	DeclareRegistrationRoutes(apiRoutes, dependancies)
+	DeclareRegistrationRoutes(apiRoutes, dep.AuthUser, dep.CaptchaVerifier)
-	DeclareResolverRoutes(apiRoutes, dependancies)
+	DeclareResolverRoutes(apiRoutes, dep.Resolver)
-	DeclareServiceSpecsRoutes(apiRoutes, dependancies)
+	DeclareServiceSpecsRoutes(apiRoutes, dep.ServiceSpecs)
-	DeclareUserRecoveryRoutes(apiRoutes, dependancies, auc)
+	DeclareUserRecoveryRoutes(apiRoutes, dep.AuthUser, auc)
 	DeclareVersionRoutes(apiRoutes)
 
 	apiAuthRoutes := router.Group("/api")
 
 	if cfg.NoAuth {
-		apiAuthRoutes.Use(middleware.NoAuthMiddleware(dependancies.AuthenticationUsecase()))
+		apiAuthRoutes.Use(middleware.NoAuthMiddleware(dep.Authentication))
 	} else {
-		apiAuthRoutes.Use(middleware.JwtAuthMiddleware(dependancies.AuthenticationUsecase(), cfg.JWTSigningMethod, cfg.JWTSecretKey))
+		apiAuthRoutes.Use(middleware.JwtAuthMiddleware(dep.Authentication, cfg.JWTSigningMethod, cfg.JWTSecretKey))
-		apiAuthRoutes.Use(middleware.SessionMiddleware(dependancies.AuthenticationUsecase()))
+		apiAuthRoutes.Use(middleware.SessionMiddleware(dep.Authentication))
 	}
 	apiAuthRoutes.Use(middleware.AuthRequired())
 
-	DeclareAuthenticationCheckRoutes(apiAuthRoutes, dependancies, lc)
+	DeclareAuthenticationCheckRoutes(apiAuthRoutes, lc)
-	DeclareDomainRoutes(apiAuthRoutes, dependancies)
+	DeclareDomainRoutes(apiAuthRoutes, dep.Domain, dep.DomainLog, dep.RemoteZoneImporter, dep.ZoneImporter, dep.Zone, dep.ZoneCorrectionApplier, dep.ZoneService, dep.Service)
-	DeclareProviderRoutes(apiAuthRoutes, dependancies)
+	DeclareProviderRoutes(apiAuthRoutes, dep.Provider)
-	DeclareProviderSettingsRoutes(apiAuthRoutes, dependancies)
+	DeclareProviderSettingsRoutes(apiAuthRoutes, dep.ProviderSettings)
-	DeclareRecordRoutes(apiAuthRoutes, dependancies)
+	DeclareRecordRoutes(apiAuthRoutes)
-	DeclareUsersRoutes(apiAuthRoutes, dependancies, lc)
+	DeclareUsersRoutes(apiAuthRoutes, dep.User, lc)
-	DeclareSessionRoutes(apiAuthRoutes, dependancies)
+	DeclareSessionRoutes(apiAuthRoutes, dep.Session)
 }

internal/api/route/service.go

@@ -29,15 +29,15 @@ import (
 	"git.happydns.org/happyDomain/model"
 )
 
-func DeclareZoneServiceRoutes(apiZonesRoutes, apiZonesSubdomainRoutes *gin.RouterGroup, zc *controller.ZoneController, dependancies happydns.UsecaseDependancies) {
+func DeclareZoneServiceRoutes(apiZonesRoutes, apiZonesSubdomainRoutes *gin.RouterGroup, zc *controller.ZoneController, zoneServiceUC happydns.ZoneServiceUsecase, serviceUC happydns.ServiceUsecase, zoneUC happydns.ZoneUsecase) {
-	sc := controller.NewServiceController(dependancies.ZoneServiceUsecase(), dependancies.ServiceUsecase(), dependancies.ZoneUsecase())
+	sc := controller.NewServiceController(zoneServiceUC, serviceUC, zoneUC)
 
 	apiZonesRoutes.PATCH("", sc.UpdateZoneService)
 
 	apiZonesSubdomainRoutes.POST("/services", sc.AddZoneService)
 
 	apiZonesSubdomainServiceIdRoutes := apiZonesSubdomainRoutes.Group("/services/:serviceid")
-	apiZonesSubdomainServiceIdRoutes.Use(middleware.ServiceIdHandler(dependancies.ServiceUsecase()))
+	apiZonesSubdomainServiceIdRoutes.Use(middleware.ServiceIdHandler(serviceUC))
 	apiZonesSubdomainServiceIdRoutes.GET("", sc.GetZoneService)
 	apiZonesSubdomainServiceIdRoutes.DELETE("", sc.DeleteZoneService)
 }

internal/api/route/service_specs.go

@@ -29,8 +29,8 @@ import (
 	"git.happydns.org/happyDomain/model"
 )
 
-func DeclareServiceSpecsRoutes(router *gin.RouterGroup, dependancies happydns.UsecaseDependancies) {
+func DeclareServiceSpecsRoutes(router *gin.RouterGroup, serviceSpecsUC happydns.ServiceSpecsUsecase) {
-	ssc := controller.NewServiceSpecsController(dependancies.ServiceSpecsUsecase())
+	ssc := controller.NewServiceSpecsController(serviceSpecsUC)
 
 	router.GET("/service_specs", ssc.ListServiceSpecs)
 

internal/api/route/session.go

@@ -28,8 +28,8 @@ import (
 	"git.happydns.org/happyDomain/model"
 )
 
-func DeclareSessionRoutes(router *gin.RouterGroup, dependancies happydns.UsecaseDependancies) {
+func DeclareSessionRoutes(router *gin.RouterGroup, sessionUC happydns.SessionUsecase) {
-	sc := controller.NewSessionController(dependancies.SessionUsecase())
+	sc := controller.NewSessionController(sessionUC)
 
 	router.GET("/session", sc.GetSession)
 	router.DELETE("/session", sc.ClearSession)

internal/api/route/user.go

@@ -29,17 +29,17 @@ import (
 	"git.happydns.org/happyDomain/model"
 )
 
-func DeclareUsersRoutes(router *gin.RouterGroup, dependancies happydns.UsecaseDependancies, lc *controller.LoginController) *controller.UserController {
+func DeclareUsersRoutes(router *gin.RouterGroup, userUC happydns.UserUsecase, lc *controller.LoginController) *controller.UserController {
-	uc := controller.NewUserController(dependancies.UserUsecase(), lc)
+	uc := controller.NewUserController(userUC, lc)
 
 	apiUserRoutes := router.Group("/users/:uid")
-	apiUserRoutes.Use(middleware.UserHandler(dependancies.UserUsecase()))
+	apiUserRoutes.Use(middleware.UserHandler(userUC))
 
 	apiUserRoutes.GET("", uc.GetUser)
 	apiUserRoutes.GET("/avatar.png", uc.GetUserAvatar)
 
 	apiSameUserRoutes := router.Group("/users/:uid")
-	apiSameUserRoutes.Use(middleware.UserHandler(dependancies.UserUsecase()))
+	apiSameUserRoutes.Use(middleware.UserHandler(userUC))
 	apiSameUserRoutes.Use(middleware.SameUserHandler)
 
 	apiSameUserRoutes.DELETE("", uc.DeleteMyUser)

internal/api/route/user_recovery.go

@@ -29,13 +29,13 @@ import (
 	"git.happydns.org/happyDomain/model"
 )
 
-func DeclareUserRecoveryRoutes(router *gin.RouterGroup, dependancies happydns.UsecaseDependancies, auc *controller.AuthUserController) *controller.UserRecoveryController {
+func DeclareUserRecoveryRoutes(router *gin.RouterGroup, authUserUC happydns.AuthUserUsecase, auc *controller.AuthUserController) *controller.UserRecoveryController {
-	urc := controller.NewUserRecoveryController(dependancies.AuthUserUsecase())
+	urc := controller.NewUserRecoveryController(authUserUC)
 
 	router.PATCH("/users", urc.UserRecoveryOperations)
 
 	apiUserRoutes := router.Group("/users/:uid")
-	apiUserRoutes.Use(middleware.AuthUserHandler(dependancies.AuthUserUsecase()))
+	apiUserRoutes.Use(middleware.AuthUserHandler(authUserUC))
 
 	apiUserRoutes.POST("/email", urc.ValidateUserAddress)
 	apiUserRoutes.POST("/recovery", urc.RecoverUserAccount)

internal/api/route/user_registration.go

@@ -28,8 +28,8 @@ import (
 	"git.happydns.org/happyDomain/model"
 )
 
-func DeclareRegistrationRoutes(router *gin.RouterGroup, dependancies happydns.UsecaseDependancies) *controller.RegistrationController {
+func DeclareRegistrationRoutes(router *gin.RouterGroup, authUserUC happydns.AuthUserUsecase, captchaVerifier happydns.CaptchaVerifier) *controller.RegistrationController {
-	rc := controller.NewRegistrationController(dependancies.AuthUserUsecase(), dependancies.CaptchaVerifier())
+	rc := controller.NewRegistrationController(authUserUC, captchaVerifier)
 
 	router.POST("/users", rc.RegisterNewUser)
 

internal/api/route/zone.go

@@ -29,15 +29,15 @@ import (
 	happydns "git.happydns.org/happyDomain/model"
 )
 
-func DeclareZoneRoutes(router *gin.RouterGroup, dependancies happydns.UsecaseDependancies) {
+func DeclareZoneRoutes(router *gin.RouterGroup, zoneUC happydns.ZoneUsecase, domainUC happydns.DomainUsecase, zoneCorrApplier happydns.ZoneCorrectionApplierUsecase, zoneServiceUC happydns.ZoneServiceUsecase, serviceUC happydns.ServiceUsecase) {
 	zc := controller.NewZoneController(
-		dependancies.ZoneUsecase(),
+		zoneUC,
-		dependancies.DomainUsecase(),
+		domainUC,
-		dependancies.ZoneCorrectionApplierUsecase(),
+		zoneCorrApplier,
 	)
 
 	apiZonesRoutes := router.Group("/zone/:zoneid")
-	apiZonesRoutes.Use(middleware.ZoneHandler(dependancies.ZoneUsecase()))
+	apiZonesRoutes.Use(middleware.ZoneHandler(zoneUC))
 
 	apiZonesRoutes.GET("", zc.GetZone)
 
@@ -50,7 +50,7 @@ func DeclareZoneRoutes(router *gin.RouterGroup, dependancies happydns.UsecaseDep
 	apiZonesSubdomainRoutes.Use(middleware.SubdomainHandler)
 	apiZonesSubdomainRoutes.GET("", zc.GetZoneSubdomain)
 
-	DeclareZoneServiceRoutes(apiZonesRoutes, apiZonesSubdomainRoutes, zc, dependancies)
+	DeclareZoneServiceRoutes(apiZonesRoutes, apiZonesSubdomainRoutes, zc, zoneServiceUC, serviceUC, zoneUC)
 
 	apiZonesRoutes.POST("/records", zc.AddRecords)
 	apiZonesRoutes.POST("/records/delete", zc.DeleteRecords)

internal/app/admin.go

@@ -53,10 +53,21 @@ func NewAdmin(app *App) *Admin {
 	router := gin.New()
 	router.Use(gin.Logger(), gin.Recovery())
 
-	// Prepare usecases
+	// Prepare usecases (admin uses unrestricted provider access)
 	app.usecases.providerAdmin = providerUC.NewService(app.store)
 
-	admin.DeclareRoutes(app.cfg, router, app.store, app)
+	admin.DeclareRoutes(app.cfg, router, app.store, admin.Dependencies{
+		AuthUser:              app.usecases.authUser,
+		Domain:                app.usecases.domain,
+		Provider:              app.usecases.providerAdmin,
+		RemoteZoneImporter:    app.usecases.orchestrator.RemoteZoneImporter,
+		Service:               app.usecases.service,
+		User:                  app.usecases.user,
+		Zone:                  app.usecases.zone,
+		ZoneCorrectionApplier: app.usecases.orchestrator.ZoneCorrectionApplier,
+		ZoneImporter:          app.usecases.orchestrator.ZoneImporter,
+		ZoneService:           app.usecases.zoneService,
+	})
 	web.DeclareRoutes(app.cfg, router)
 
 	return &Admin{

internal/app/app.go

@@ -84,89 +84,6 @@ type App struct {
 	usecases        Usecases
 }
 
-func (a *App) AuthenticationUsecase() happydns.AuthenticationUsecase {
-	return a.usecases.authentication
-}
-
-func (a *App) AuthUserUsecase() happydns.AuthUserUsecase {
-	return a.usecases.authUser
-}
-
-func (a *App) CaptchaVerifier() happydns.CaptchaVerifier {
-	return a.captchaVerifier
-}
-
-func (a *App) DomainUsecase() happydns.DomainUsecase {
-	return a.usecases.domain
-}
-
-func (a *App) DomainLogUsecase() happydns.DomainLogUsecase {
-	return a.usecases.domainLog
-}
-
-func (a *App) FailureTracker() happydns.FailureTracker {
-	return a.failureTracker
-}
-
-func (a *App) Orchestrator() *orchestrator.Orchestrator {
-	return a.usecases.orchestrator
-}
-
-func (a *App) ProviderUsecase(secure bool) happydns.ProviderUsecase {
-	if secure {
-		return a.usecases.provider
-	} else {
-		return a.usecases.providerAdmin
-	}
-}
-
-func (a *App) ProviderSettingsUsecase() happydns.ProviderSettingsUsecase {
-	return a.usecases.providerSettings
-}
-
-func (a *App) ProviderSpecsUsecase() happydns.ProviderSpecsUsecase {
-	return a.usecases.providerSpecs
-}
-
-func (a *App) ResolverUsecase() happydns.ResolverUsecase {
-	return a.usecases.resolver
-}
-
-func (a *App) RemoteZoneImporterUsecase() happydns.RemoteZoneImporterUsecase {
-	return a.usecases.orchestrator.RemoteZoneImporter
-}
-
-func (a *App) ServiceUsecase() happydns.ServiceUsecase {
-	return a.usecases.service
-}
-
-func (a *App) ServiceSpecsUsecase() happydns.ServiceSpecsUsecase {
-	return a.usecases.serviceSpecs
-}
-
-func (a *App) SessionUsecase() happydns.SessionUsecase {
-	return a.usecases.session
-}
-
-func (a *App) UserUsecase() happydns.UserUsecase {
-	return a.usecases.user
-}
-
-func (a *App) ZoneCorrectionApplierUsecase() happydns.ZoneCorrectionApplierUsecase {
-	return a.usecases.orchestrator.ZoneCorrectionApplier
-}
-
-func (a *App) ZoneImporterUsecase() happydns.ZoneImporterUsecase {
-	return a.usecases.orchestrator.ZoneImporter
-}
-
-func (a *App) ZoneUsecase() happydns.ZoneUsecase {
-	return a.usecases.zone
-}
-
-func (a *App) ZoneServiceUsecase() happydns.ZoneServiceUsecase {
-	return a.usecases.zoneService
-}
 
 func NewApp(cfg *happydns.Options) *App {
 	app := &App{
@@ -319,7 +236,27 @@ func (app *App) setupRouter() {
 		session.NewSessionStore(app.cfg, app.store, []byte(app.cfg.JWTSecretKey)),
 	))
 
-	api.DeclareRoutes(app.cfg, app.router, app)
+	api.DeclareRoutes(app.cfg, app.router, api.Dependencies{
+		Authentication:        app.usecases.authentication,
+		AuthUser:              app.usecases.authUser,
+		CaptchaVerifier:       app.captchaVerifier,
+		Domain:                app.usecases.domain,
+		DomainLog:             app.usecases.domainLog,
+		FailureTracker:        app.failureTracker,
+		Provider:              app.usecases.provider,
+		ProviderSettings:      app.usecases.providerSettings,
+		ProviderSpecs:         app.usecases.providerSpecs,
+		RemoteZoneImporter:    app.usecases.orchestrator.RemoteZoneImporter,
+		Resolver:              app.usecases.resolver,
+		Service:               app.usecases.service,
+		ServiceSpecs:          app.usecases.serviceSpecs,
+		Session:               app.usecases.session,
+		User:                  app.usecases.user,
+		Zone:                  app.usecases.zone,
+		ZoneCorrectionApplier: app.usecases.orchestrator.ZoneCorrectionApplier,
+		ZoneImporter:          app.usecases.orchestrator.ZoneImporter,
+		ZoneService:           app.usecases.zoneService,
+	})
 	web.DeclareRoutes(app.cfg, app.router, app.captchaVerifier)
 }
 

model/usecase.go

@@ -1,44 +0,0 @@
-// This file is part of the happyDomain (R) project.
-// Copyright (c) 2020-2024 happyDomain
-// Authors: Pierre-Olivier Mercier, et al.
-//
-// This program is offered under a commercial and under the AGPL license.
-// For commercial licensing, contact us at <contact@happydomain.org>.
-//
-// For AGPL licensing:
-// This program is free software: you can redistribute it and/or modify
-// it under the terms of the GNU Affero General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-//
-// This program is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-// GNU Affero General Public License for more details.
-//
-// You should have received a copy of the GNU Affero General Public License
-// along with this program.  If not, see <https://www.gnu.org/licenses/>.
-
-package happydns
-
-type UsecaseDependancies interface {
-	AuthenticationUsecase() AuthenticationUsecase
-	AuthUserUsecase() AuthUserUsecase
-	CaptchaVerifier() CaptchaVerifier
-	DomainUsecase() DomainUsecase
-	DomainLogUsecase() DomainLogUsecase
-	FailureTracker() FailureTracker
-	ProviderUsecase(secure bool) ProviderUsecase
-	ProviderSettingsUsecase() ProviderSettingsUsecase
-	ProviderSpecsUsecase() ProviderSpecsUsecase
-	RemoteZoneImporterUsecase() RemoteZoneImporterUsecase
-	ResolverUsecase() ResolverUsecase
-	ServiceUsecase() ServiceUsecase
-	ServiceSpecsUsecase() ServiceSpecsUsecase
-	SessionUsecase() SessionUsecase
-	UserUsecase() UserUsecase
-	ZoneCorrectionApplierUsecase() ZoneCorrectionApplierUsecase
-	ZoneImporterUsecase() ZoneImporterUsecase
-	ZoneServiceUsecase() ZoneServiceUsecase
-	ZoneUsecase() ZoneUsecase
-}