Project Layout & Dependency Injection

package main

import (
"errors"
"fmt"
"sort"
)

// Store is the small interface the Service depends on.
// The Service never names a concrete database — only this contract.
type Store interface {
Save(id string, balance int) error
Get(id string) (int, error)
}

// Service holds business logic. It depends on the Store INTERFACE,
// not on any particular implementation.
type Service struct {
store Store
}

// NewService is the constructor: dependencies arrive as arguments.
func NewService(s Store) *Service {
return &Service{store: s}
}

func (svc *Service) Open(id string, opening int) error {
if opening < 0 {
	return errors.New("opening balance cannot be negative")
}
return svc.store.Save(id, opening)
}

func (svc *Service) Deposit(id string, amount int) (int, error) {
bal, err := svc.store.Get(id)
if err != nil {
	return 0, err
}
bal += amount
if err := svc.store.Save(id, bal); err != nil {
	return 0, err
}
return bal, nil
}

// memStore is an in-memory Store. In production this would be SQL-backed;
// in tests you would pass a fake. The Service cannot tell the difference.
type memStore struct{ data map[string]int }

func newMemStore() *memStore { return &memStore{data: map[string]int{}} }

func (m *memStore) Save(id string, balance int) error {
m.data[id] = balance
return nil
}

func (m *memStore) Get(id string) (int, error) {
bal, ok := m.data[id]
if !ok {
	return 0, fmt.Errorf("account %q not found", id)
}
return bal, nil
}

func main() {
// Wiring happens HERE in main: choose the implementation and inject it.
// Swap newMemStore() for a SQL store without touching Service at all.
svc := NewService(newMemStore())

_ = svc.Open("alice", 100)
_ = svc.Open("bob", 50)

bal, _ := svc.Deposit("alice", 25)
fmt.Println("alice balance:", bal) // 125

bobBal, _ := svc.Deposit("bob", 10)
fmt.Println("bob balance:  ", bobBal) // 60

ids := []string{"alice", "bob"}
sort.Strings(ids) // deterministic output
fmt.Println("accounts:", ids)
}