Dependency Injection #

// ANTI-PATTERN: UserService membuat dependency sendiri — hidden coupling
type UserService struct{}

func (s *UserService) GetUser(id string) (*User, error) {
    repo := NewMySQLUserRepository() // ← dibuat di dalam — tidak bisa ditest
    return repo.FindByID(id)
}

// BENAR: dependency diterima dari luar via constructor
type UserService struct {
    repo UserRepository // ← interface, bukan implementasi konkret
}

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

func (s *UserService) GetUser(id string) (*User, error) {
    return s.repo.FindByID(id) // tidak tahu MySQL, PostgreSQL, atau 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 {
    // Semua dependency terlihat jelas di sini — tidak ada yang tersembunyi
    return &OrderService{repo: repo, emailer: emailer, logger: logger}
}

// Go — constructor injection (semua dependency wajib)
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(email, password string) error {
    token, err := b.repository.Login(email, password)
    if err != nil {
        return err
    }
    if err := b.tokenStorage.Save(token); err != nil {
        return err
    }
    b.analytics.Track("user_logged_in", map[string]string{"email": email})
    return nil
}

// Testing: inject fake implementation
func main() {
    bloc := NewAuthBloc(
        FakeAuthRepository(),     // ← fake, bukan network
        InMemoryTokenStorage(),   // ← fake, bukan Hive/SharedPrefs
        NoOpAnalytics(),          // ← fake, tidak kirim event nyata
    )
    _ = bloc
}

// Go — constructor injection (pola yang direkomendasikan)
type PaymentService struct {
    repo     PaymentRepository
    notifier NotificationService
}

// Dependency wajib lewat constructor — tidak ada framework magic
func NewPaymentService(repo PaymentRepository, notifier NotificationService) *PaymentService {
    return &PaymentService{repo: repo, notifier: notifier}
}

// BENAR: setter injection untuk dependency opsional dengan 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, // ← default yang masuk akal
    }
}

// Setter hanya untuk override default — opsional
func (s *EmailService) SetRateLimit(limit int) {
    s.rateLimit = limit
}

// ANTI-PATTERN: setter injection untuk dependency wajib
type UserService struct {
    repo UserRepository // wajib, tapi tidak di-enforce lewat constructor
}

func NewUserService() *UserService {
    return &UserService{} // repo masih nil — bom waktu!
}

func (s *UserService) SetRepo(repo UserRepository) {
    s.repo = repo
}
// Jika caller lupa memanggil SetRepo → s.repo nil → panic saat dipakai

// Parameter injection — context dan transaction diinjeksikan per-call
func ProcessRefund(
    ctx        context.Context, // ← context berbeda setiap request
    tx         *sql.Tx,         // ← transaction berbeda per-operasi
    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 — semua wiring eksplisit, tidak ada magic
func main() {
    // Layer infrastruktur
    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"),
    })

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

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

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

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

// Go dengan Uber FX — framework DI berbasis functional options
func main() {
    fx.New(
        fx.Provide(
            database.NewPostgresDB,   // provide *sql.DB
            cache.NewRedisClient,     // provide *redis.Client
            repository.NewUserRepo,   // butuh *sql.DB, provide UserRepository
            repository.NewOrderRepo,  // butuh *sql.DB, provide OrderRepository
            cache.NewRedisCache,      // butuh *redis.Client, provide CacheStore
            service.NewUserService,   // butuh UserRepository + CacheStore
            service.NewOrderService,  // butuh OrderRepository + UserService
            handler.NewUserHandler,   // butuh UserService
            handler.NewOrderHandler,  // butuh OrderService
        ),
        fx.Invoke(startHTTPServer),
    ).Run()
    // FX otomatis resolve semua dependency berdasarkan type signature
    // Tidak perlu tulis urutan manual
}

// Go — service locator tidak umum; pola terdekat adalah registry map
// (wiring manual di composition root tetap lebih transparan)
var registry = map[string]any{}

func SetupDependencies() {
    // Infrastruktur
    registry["httpClient"] = NewHTTPClient(Env.APIURL)
    registry["storage"] = NewHiveStorage()

    // Repository
    registry["authRepository"] = NewAuthRepositoryImpl(registry["httpClient"].(*HTTPClient))
    registry["userRepository"] = NewUserRepositoryImpl(
        registry["httpClient"].(*HTTPClient),
        registry["storage"].(*HiveStorage),
    )

    // BLoC / Service — factory: instance baru setiap kali diambil
    registry["authBlocFactory"] = func() *AuthBloc {
        return NewAuthBloc(
            registry["authRepository"].(AuthRepository),
            registry["storage"].(TokenStorage),
        )
    }
}

// Interface yang sama diimplementasikan oleh produksi dan fake
type UserRepository interface {
    Save(ctx context.Context, user *User) error
    FindByEmail(ctx context.Context, email string) (*User, error)
}

// Produksi: pakai 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, tidak butuh infrastruktur apapun
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
}

// Test berjalan dalam milidetik, tidak butuh Docker/database
func TestRegisterUser_EmailAlreadyExists(t *testing.T) {
    repo    := NewInMemoryUserRepository()
    emailer := &FakeEmailSender{}
    svc     := NewUserService(repo, emailer)

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

    // Test: registrasi dengan email yang sama harus gagal
    _, err := svc.Register(context.Background(), RegisterRequest{
        Email: "[email protected]",
        Name:  "Someone Else",
    })

    assert.ErrorIs(t, err, ErrEmailAlreadyExists)
    assert.Empty(t, emailer.SentEmails) // tidak ada email yang dikirim
}

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 terkirim
}

// ANTI-PATTERN: buat koneksi DB setiap request — sangat mahal dan lambat
func handleGetUser(w http.ResponseWriter, r *http.Request) {
    db, _ := sql.Open("postgres", os.Getenv("DATABASE_URL")) // ← boros!
    defer db.Close()
    repo := repository.NewUserRepository(db)
    // ...
}

// BENAR: singleton — connection pool dibuat sekali, dibagikan ke semua handler
func main() {
    db, _ := sql.Open("postgres", os.Getenv("DATABASE_URL"))
    db.SetMaxOpenConns(25)   // max 25 koneksi concurrent
    db.SetMaxIdleConns(10)   // min 10 koneksi siap pakai

    // Singleton: dibuat sekali, digunakan sepanjang lifetime aplikasi
    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 — scope dengan composition root manual
type Container struct {
    apiClient *ApiClient
    authRepo  AuthRepository
}

func NewContainer() *Container {
    // Singleton: satu instance seumur lifetime app
    c := &Container{apiClient: NewApiClient(Env.APIURL)}
    // LazySingleton: di Go cukup dibuat sekali di sini
    c.authRepo = NewAuthRepositoryImpl(c.apiClient)
    return c
}

// Factory: instance baru setiap kali dipanggil
// Cocok untuk BLoC yang di-dispose dan di-recreate per screen
func (c *Container) NewAuthBloc() *AuthBloc {
    return NewAuthBloc(c.authRepo)
}

// ✗ Membuat dependency di dalam method — IoC dilanggar kembali
func (s *OrderService) CreateOrder(req Request) (*Order, error) {
    repo := &MySQLOrderRepository{db: globalDB} // ← tight coupling kembali!
    return repo.Save(buildOrder(req))
}
// ✓ Gunakan s.repo yang sudah diinjeksikan via constructor

// ✗ Global variable sebagai dependency — tidak bisa di-mock, race condition
var globalDB *sql.DB

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

// ✗ God constructor — tanda service melakukan terlalu banyak hal
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 dependency = OrderService melakukan terlalu banyak → pecah menjadi service lebih kecil
// ✓ Jika > 4-5 dependency, evaluasi apakah SRP sudah terpenuhi

// ✗ Inject concrete type bukan interface
func NewOrderService(repo *MySQLOrderRepository) *OrderService { ... }
// ✓ Inject interface
func NewOrderService(repo OrderRepository) *OrderService { ... }

// ✗ Setter injection untuk dependency wajib — bisa digunakan dalam state invalid
type UserService struct{ repo UserRepository }
func NewUserService() *UserService { return &UserService{} } // repo = nil!
func (s *UserService) SetRepo(r UserRepository) { s.repo = r }
// ✓ Constructor injection untuk dependency wajib
func NewUserService(repo UserRepository) *UserService {
    return &UserService{repo: repo} // compiler error jika tidak ada repo
}

// ✗ Inject IoC container ke dalam service — service tahu tentang container
type OrderService struct { container *Container }
func (s *OrderService) CreateOrder(req Request) error {
    repo := s.container.Get("orderRepo").(OrderRepository) // hidden dependency!
    ...
}
// ✓ Inject dependency langsung, bukan container