services := godi.NewCollection() services.AddSingleton(NewDatabase) // One instance, shared everywhere services.AddScoped(NewUserService) // One instance per request services.AddTransient(NewEmailBuilder) // New instance every time provider, _ := services.Build() user := godi.MustResolve[*UserService](provider)

// Manual wiring - gets messy fast config := NewConfig() logger := NewLogger(config) db := NewDatabase(config, logger) cache := NewCache(config, logger) userRepo := NewUserRepository(db, cache, logger) orderRepo := NewOrderRepository(db, cache, logger) userService := NewUserService(userRepo, logger) orderService := NewOrderService(orderRepo, userService, logger) // ... 20 more lines

// godi - register in any order, resolve anything services := godi.NewCollection() services.AddSingleton(NewConfig) services.AddSingleton(NewLogger) services.AddSingleton(NewDatabase) services.AddScoped(NewUserService) // ... godi handles the wiring

package main import ( "fmt" "github.com/junioryono/godi/v4" ) type Logger struct{} func (l *Logger) Log(msg string) { fmt.Println(msg) } func NewLogger() *Logger { return &Logger{} } type UserService struct { logger *Logger } func NewUserService(logger *Logger) *UserService { return &UserService{logger: logger} } func (s *UserService) Greet() { s.logger.Log("Hello from UserService!") } func main() { // 1. Register services services := godi.NewCollection() services.AddSingleton(NewLogger) services.AddSingleton(NewUserService) // 2. Build the container provider, _ := services.Build() defer provider.Close() // 3. Resolve and use - dependencies wired automatically users := godi.MustResolve[*UserService](provider) users.Greet() // Hello from UserService! }

services.AddSingleton(NewDatabasePool) // One pool for the whole app services.AddScoped(NewTransaction) // Fresh transaction per request services.AddTransient(NewQueryBuilder) // New builder every resolution

package main import ( "net/http" "github.com/junioryono/godi/v4" godihttp "github.com/junioryono/godi/v4/http" ) type UserController struct { // Dependencies injected automatically } func (c *UserController) List(w http.ResponseWriter, r *http.Request) { w.Write([]byte(`["alice", "bob"]`)) } func main() { services := godi.NewCollection() services.AddSingleton(NewLogger) services.AddScoped(NewUserController) provider, _ := services.Build() defer provider.Close() mux := http.NewServeMux() mux.HandleFunc("GET /users", godihttp.Handle((*UserController).List)) // ScopeMiddleware creates a fresh scope per request handler := godihttp.ScopeMiddleware(provider)(mux) http.ListenAndServe(":8080", handler) }

services.AddSingleton(NewConsoleLogger, godi.As[Logger]()) // Resolve by interface logger := godi.MustResolve[Logger](provider)

services.AddSingleton(NewPrimaryDB, godi.Name("primary")) services.AddSingleton(NewReplicaDB, godi.Name("replica")) primary := godi.MustResolveKeyed[Database](provider, "primary") replica := godi.MustResolveKeyed[Database](provider, "replica")

services.AddSingleton(NewEmailValidator, godi.Group("validators")) services.AddSingleton(NewPhoneValidator, godi.Group("validators")) validators := godi.MustResolveGroup[Validator](provider, "validators") for _, v := range validators { v.Validate(input) }

type ServiceParams struct { godi.In DB Database Cache Cache Logger Logger Metrics Metrics `optional:"true"` } func NewService(params ServiceParams) *Service { return &Service{db: params.DB, cache: params.Cache} }

type InfraResult struct { godi.Out DB *Database Cache *Cache Health *HealthChecker } func NewInfra(cfg *Config) InfraResult { db := connectDB(cfg) return InfraResult{ DB: db, Cache: NewCache(cfg), Health: NewHealthChecker(db), } } // One registration, three services services.AddSingleton(NewInfra)

// users/module.go var Module = godi.NewModule("users", godi.AddScoped(NewUserRepository), godi.AddScoped(NewUserService), ) // main.go services.AddModules( infrastructure.Module, users.Module, orders.Module, )

func (d *Database) Close() error { return d.conn.Close() } provider.Close() // Database.Close() called automatically

provider, err := services.Build() if err != nil { // Circular dependency? Missing service? Lifetime conflict? // The error message tells you exactly what's wrong log.Fatal(err) }

func TestUserService(t *testing.T) { services := godi.NewCollection() services.AddSingleton(func() Database { return &MockDB{} }) services.AddScoped(NewUserService) provider, _ := services.Build() defer provider.Close() scope, _ := provider.CreateScope(context.Background()) defer scope.Close() svc := godi.MustResolve[*UserService](scope) // Test with mock database }