di

Dependency Injection

Overview

Rules for the Dependency Injection (DI) layer in go-crypto-wallet. The DI layer is responsible for wiring all dependencies and should follow Clean Architecture principles.

Applicable Files

• internal/di/container.go - Application DI container
• pkg/di/container.go - Infrastructure/pkg DI container

Core Principles

1. Pure Constructor Pattern (Mandatory)

Constructors must be pure assembly functions. They only:

• Receive dependencies as parameters
• Assign parameters to struct fields
• Return the constructed instance

DO NOT create internal objects within constructors:

// ✅ GOOD: Pure constructor - just assembles the struct
func NewCreateTransactionUseCase(
    btcClient apibtc.Bitcoiner,
    dbConn *sql.DB,
    addrRepo repowatch.AddressRepositorier,
    txRepo repowatch.BTCTxRepositorier,
) watchusecase.CreateTransactionUseCase {
    return &createTransactionUseCase{
        btcClient: btcClient,
        dbConn:    dbConn,
        addrRepo:  addrRepo,
        txRepo:    txRepo,
    }
}

// ❌ BAD: Constructor creates internal dependencies
func NewCreateTransactionUseCase(
    conf *config.Config,
) watchusecase.CreateTransactionUseCase {
    // DON'T create dependencies inside constructor
    btcClient := bitcoin.NewBitcoin(conf)
    dbConn := mysql.NewConnection(conf.Database)
    return &createTransactionUseCase{
        btcClient: btcClient,
        dbConn:    dbConn,
    }
}

2. No Factory Pattern for Domain/Application Objects

Factory patterns add unnecessary indirection. Use direct constructor calls instead:

// ✅ GOOD: Direct constructor call
useCase := keygenusecasebtc.NewImportPrivateKeyUseCase(
    btcClient,
    accountKeyRepo,
)

// ❌ BAD: Factory pattern
factory := usecaseFactory.New()
useCase := factory.CreateImportPrivateKeyUseCase()

Exception: Factory pattern is acceptable only for infrastructure components that require runtime type selection (e.g., key generators based on address type).