Dependency Injection #

// ANTI-PATTERN: UserService creates its own dependency — hidden coupling
type UserService struct{}

func (s *UserService) GetUser(id string) (*User, error) {
    repo := NewMySQLUserRepository() // ← created inside — can't be tested
    return repo.FindByID(id)
}

// CORRECT: the dependency is received from outside via the constructor
type UserService struct {
    repo UserRepository // ← interface, not a concrete implementation
}

func NewUserService(repo UserRepository) *UserService {
    return &UserService{repo: repo}
}

func (s *UserService) GetUser(id string) (*User, error) {
    return s.repo.FindByID(id) // doesn't know MySQL, PostgreSQL, or in-memory
}

// Go — constructor injection
type OrderService struct {
    repo    OrderRepository  // interface
    emailer EmailSender      // interface
    logger  Logger           // interface
}

func NewOrderService(
    repo    OrderRepository,
    emailer EmailSender,
    logger  Logger,
) *OrderService {
    // All dependencies are clearly visible here — nothing hidden
    return &OrderService{repo: repo, emailer: emailer, logger: logger}
}

// Go — constructor injection with a struct + constructor
type AuthBloc struct {
    repository   AuthRepository
    tokenStorage TokenStorage
    analytics    AnalyticsService
}

func NewAuthBloc(
    repository AuthRepository,
    tokenStorage TokenStorage,
    analytics AnalyticsService,
) *AuthBloc {
    return &AuthBloc{
        repository:   repository,
        tokenStorage: tokenStorage,
        analytics:    analytics,
    }
}

func (b *AuthBloc) Login(ctx context.Context, email, password string) error {
    token, err := b.repository.Login(ctx, email, password)
    if err != nil {
        return err
    }
    if err := b.tokenStorage.Save(ctx, token); err != nil {
        return err
    }
    b.analytics.Track("user_logged_in", map[string]string{"email": email})
    return nil
}

// Testing: inject fake implementations
func main() {
    bloc := NewAuthBloc(
        FakeAuthRepository(),     // ← fake, not network
        InMemoryTokenStorage(),   // ← fake, not Hive/SharedPrefs
        NoOpAnalytics(),          // ← fake, doesn't send real events
    )
}

// Go — constructor injection (no framework magic needed)
type PaymentService struct {
    repo     PaymentRepository
    notifier NotificationService
}

// The constructor is the single wiring point — no annotations required
func NewPaymentService(repo PaymentRepository, notifier NotificationService) *PaymentService {
    return &PaymentService{repo: repo, notifier: notifier}
}

// CORRECT: setter injection for an optional dependency with a default
type EmailService struct {
    sender    EmailSender
    logger    Logger
    rateLimit int
}

func NewEmailService(sender EmailSender, logger Logger) *EmailService {
    return &EmailService{
        sender:    sender,
        logger:    logger,
        rateLimit: 100, // ← a sensible default
    }
}

// Setter only to override the default — optional
func (s *EmailService) SetRateLimit(limit int) {
    s.rateLimit = limit
}

// ANTI-PATTERN: setter injection for a required dependency
type UserService struct {
    repo UserRepository // required, but not enforced via the constructor
}

func NewUserService() *UserService {
    return &UserService{} // repo is still nil — a ticking time bomb!
}

func (s *UserService) SetRepo(repo UserRepository) {
    s.repo = repo
}
// If the caller forgets to call SetRepo → s.repo is nil → panic when used

// Parameter injection — context and transactions injected per-call
func ProcessRefund(
    ctx        context.Context, // ← different context per request
    tx         *sql.Tx,         // ← different transaction per operation
    refundRepo RefundRepository,
    orderRepo  OrderRepository,
    refundID   string,
) error {
    refund, err := refundRepo.FindByID(ctx, refundID)
    if err != nil {
        return err
    }
    order, err := orderRepo.FindByID(ctx, refund.OrderID)
    if err != nil {
        return err
    }
    return refundRepo.MarkCompleted(ctx, tx, refund, order)
}

// main.go — all wiring explicit, no magic
func main() {
    // Infrastructure layer
    db, err := sql.Open("postgres", os.Getenv("DATABASE_URL"))
    if err != nil { log.Fatal(err) }
    db.SetMaxOpenConns(25)
    db.SetMaxIdleConns(10)

    redisClient := redis.NewClient(&redis.Options{
        Addr: os.Getenv("REDIS_URL"),
    })

    // Repository layer
    userRepo  := repository.NewUserRepository(db)
    orderRepo := repository.NewOrderRepository(db)
    cache     := cache.NewRedisCache(redisClient)

    // Service layer
    userService  := service.NewUserService(userRepo, cache)
    orderService := service.NewOrderService(orderRepo, userService)

    // Handler layer
    userHandler  := handler.NewUserHandler(userService)
    orderHandler := handler.NewOrderHandler(orderService)

    // Server
    router := setupRouter(userHandler, orderHandler)
    log.Fatal(http.ListenAndServe(":8080", router))
}

// Go with Uber FX — a functional-options-based DI framework
func main() {
    fx.New(
        fx.Provide(
            database.NewPostgresDB,   // provides *sql.DB
            cache.NewRedisClient,     // provides *redis.Client
            repository.NewUserRepo,   // needs *sql.DB, provides UserRepository
            repository.NewOrderRepo,  // needs *sql.DB, provides OrderRepository
            cache.NewRedisCache,      // needs *redis.Client, provides CacheStore
            service.NewUserService,   // needs UserRepository + CacheStore
            service.NewOrderService,  // needs OrderRepository + UserService
            handler.NewUserHandler,   // needs UserService
            handler.NewOrderHandler,  // needs OrderService
        ),
        fx.Invoke(startHTTPServer),
    ).Run()
    // FX automatically resolves all dependencies based on type signatures
    // No need to write the manual order
}

// Go — manual registry, a simple service locator
func setupDependencies() {
    // Infrastructure
    container.Register("dio", NewDio(BaseOptions{BaseURL: Env.APIURL}))
    container.Register("hive", NewHiveStorage())

    // Repositories
    container.Register("authRepo", NewAuthRepositoryImpl(container.Get("dio")))
    container.Register("userRepo", NewUserRepositoryImpl(
        container.Get("dio"),
        container.Get("hive"),
    ))

    // BLoC / Service
    container.RegisterFactory("authBloc", func() interface{} {
        return NewAuthBloc(
            container.Get("authRepo"),
            container.Get("hive"),
        )
    })
}

// The same interface implemented by production and fake
type UserRepository interface {
    Save(ctx context.Context, user *User) error
    FindByEmail(ctx context.Context, email string) (*User, error)
}

// Production: uses PostgreSQL
type PostgresUserRepository struct{ db *sql.DB }

func (r *PostgresUserRepository) Save(ctx context.Context, user *User) error {
    _, err := r.db.ExecContext(ctx,
        "INSERT INTO users (id, email, name) VALUES ($1, $2, $3)",
        user.ID, user.Email, user.Name)
    return err
}

// Test: in-memory, needs no infrastructure at all
type InMemoryUserRepository struct {
    users map[string]*User
    mu    sync.RWMutex
}

func NewInMemoryUserRepository() *InMemoryUserRepository {
    return &InMemoryUserRepository{users: make(map[string]*User)}
}

func (r *InMemoryUserRepository) Save(_ context.Context, user *User) error {
    r.mu.Lock()
    defer r.mu.Unlock()
    r.users[user.Email] = user
    return nil
}

func (r *InMemoryUserRepository) FindByEmail(_ context.Context, email string) (*User, error) {
    r.mu.RLock()
    defer r.mu.RUnlock()
    if user, ok := r.users[email]; ok {
        return user, nil
    }
    return nil, ErrUserNotFound
}

// Tests run in milliseconds, no Docker/database needed
func TestRegisterUser_EmailAlreadyExists(t *testing.T) {
    repo    := NewInMemoryUserRepository()
    emailer := &FakeEmailSender{}
    svc     := NewUserService(repo, emailer)

    // Setup: user already exists
    repo.Save(context.Background(), &User{
        ID: "existing-1", Email: "[email protected]",
    })

    // Test: registering with the same email must fail
    _, err := svc.Register(context.Background(), RegisterRequest{
        Email: "[email protected]",
        Name:  "Someone Else",
    })

    assert.ErrorIs(t, err, ErrEmailAlreadyExists)
    assert.Empty(t, emailer.SentEmails) // no email was sent
}

func TestRegisterUser_Success(t *testing.T) {
    repo    := NewInMemoryUserRepository()
    emailer := &FakeEmailSender{}
    svc     := NewUserService(repo, emailer)

    user, err := svc.Register(context.Background(), RegisterRequest{
        Email: "[email protected]",
        Name:  "Unis Badri",
    })

    assert.NoError(t, err)
    assert.NotEmpty(t, user.ID)
    assert.Len(t, emailer.SentEmails, 1) // welcome email sent
}

// ANTI-PATTERN: creating a DB connection per request — very expensive and slow
func handleGetUser(w http.ResponseWriter, r *http.Request) {
    db, _ := sql.Open("postgres", os.Getenv("DATABASE_URL")) // ← wasteful!
    defer db.Close()
    repo := repository.NewUserRepository(db)
    // ...
}

// CORRECT: singleton — the connection pool is created once, shared by all handlers
func main() {
    db, _ := sql.Open("postgres", os.Getenv("DATABASE_URL"))
    db.SetMaxOpenConns(25)   // max 25 concurrent connections
    db.SetMaxIdleConns(10)   // min 10 ready connections

    // Singleton: created once, used for the entire application lifetime
    repo    := repository.NewUserRepository(db)   // singleton
    service := service.NewUserService(repo)        // singleton
    handler := handler.NewUserHandler(service)     // singleton

    http.HandleFunc("/users", handler.GetUser)
    http.ListenAndServe(":8080", nil)
}

// Go — scopes with a simple container
func setupDI() {
    c := container.New()

    // Singleton: one instance for the app's lifetime
    c.RegisterSingleton("apiClient", NewApiClient(Env.APIURL))

    // LazySingleton: a singleton, but created on first use
    c.RegisterLazySingleton("authRepo", func() interface{} {
        return NewAuthRepositoryImpl(c.Get("apiClient"))
    })

    // Factory: a new instance every time c.Get("authBloc") is called
    // Good for BLoCs that are disposed and recreated per screen
    c.RegisterFactory("authBloc", func() interface{} {
        return NewAuthBloc(c.Get("authRepo"))
    })
}

// ✗ Creating dependencies inside a method — IoC violated again
func (s *OrderService) CreateOrder(req Request) (*Order, error) {
    repo := &MySQLOrderRepository{db: globalDB} // ← tight coupling again!
    return repo.Save(buildOrder(req))
}
// ✓ Use s.repo, which was injected via the constructor

// ✗ Global variables as dependencies — can't be mocked, race conditions
var globalDB *sql.DB

func init() {
    globalDB, _ = sql.Open("postgres", os.Getenv("DATABASE_URL"))
}
// ✓ Inject *sql.DB via the constructor, not as a global

// ✗ God constructor — a sign the service is doing too much
func NewOrderService(
    repo OrderRepository,
    userRepo UserRepository,
    productRepo ProductRepository,
    inventoryRepo InventoryRepository,
    paymentGW PaymentGateway,
    emailer EmailSender,
    sms SMSSender,
    push PushNotifier,
    logger Logger,
    cache CacheStore,
    config *Config,
    bus EventBus,
) *OrderService { ... }
// 12 dependencies = OrderService is doing too much → split into smaller services
// ✓ If > 4-5 dependencies, evaluate whether SRP is satisfied

// ✗ Injecting concrete types instead of interfaces
func NewOrderService(repo *MySQLOrderRepository) *OrderService { ... }
// ✓ Inject an interface
func NewOrderService(repo OrderRepository) *OrderService { ... }

// ✗ Setter injection for required dependencies — can be used in an invalid state
type UserService struct{ repo UserRepository }
func NewUserService() *UserService { return &UserService{} } // repo = nil!
func (s *UserService) SetRepo(r UserRepository) { s.repo = r }
// ✓ Constructor injection for required dependencies
func NewUserService(repo UserRepository) *UserService {
    return &UserService{repo: repo} // compiler error if no repo
}

// ✗ Injecting the IoC container into a service — the service knows about the container
type OrderService struct { container *Container }
func (s *OrderService) CreateOrder(req Request) error {
    repo := s.container.Get("orderRepo").(OrderRepository) // hidden dependency!
    ...
}
// ✓ Inject the dependency directly, not the container