Part 2: Applying Component-Based Clean Architecture in Go

/cmd/
/internal/
  users/
  payments/
  orders/
  contracts/
  web/

// contracts/user/user_service.go
package user

type Service interface {
	GetUserByID(ctx context.Context, id string) (UserDTO, error)  // Just one method. Like a good microservice!
}

type UserDTO struct {
	ID    string  // Just what we need
	Email string  // No "PasswordHash" here
}

// internal/users/adapters/service.go
type UserService struct {
	repo UserRepository
}

func (s *UserService) GetUserByID(ctx context.Context, id string) (user.UserDTO, error) {
	u, err := s.repo.FindByID(ctx, id)
	if err != nil {
		return user.UserDTO{}, fmt.Errorf("couldn't find user %s: %w", id, err)
		// 💥 Bug: We didn't log here, and we lost the original error's type.
		// Lesson learned. See Step 4.
	}

	return user.UserDTO{
		ID:    u.ID,
		Email: u.Email,  // <- Is this valid? (Spoiler: Not always)
	}, nil
}

// components/payments/payment_component_impl/service.go
type PaymentComponentImpl struct {
	userService user.Service  // <- Depends on the CONTRACT, not on users
}

func (s *PaymentComponentImpl) Charge(ctx context.Context, userID string, amount float64) error {
	u, err := s.userService.GetUserByID(ctx, userID)
	if err != nil {
		return fmt.Errorf("payment failed for %s: %w", userID, err)
	}

	if u.Email == "" {  // 💡 Validation where it SHOULD be!
		return errors.New("email required for payments")
	}

	// ... Stripe/PayPal logic
}

// contracts/user/errors.go — define these alongside the interface
var (
	ErrNotFound = errors.New("user: not found")
	ErrInvalid  = errors.New("user: invalid data")
)

// internal/users/adapters/service.go — the fixed version of Step 2
func (s *UserService) GetUserByID(ctx context.Context, id string) (user.UserDTO, error) {
	u, err := s.repo.FindByID(ctx, id)
	if err != nil {
		if errors.Is(err, sql.ErrNoRows) {
			return user.UserDTO{}, fmt.Errorf("user %s: %w", id, user.ErrNotFound)
		}
		// Unexpected DB error — wrap and bubble up, log here
		return user.UserDTO{}, fmt.Errorf("user %s: %w", id, err)
	}
	return user.UserDTO{ID: u.ID, Email: u.Email}, nil
}

// web/user_handler.go
func (h *UserHandler) GetUser(c *gin.Context) {
	u, err := h.userService.GetUserByID(c.Request.Context(), c.Param("id"))
	if err != nil {
		switch {
		case errors.Is(err, user.ErrNotFound):
			c.JSON(http.StatusNotFound, gin.H{"error": "user not found"})
		default:
			// Never leak internal details over the wire
			c.JSON(http.StatusInternalServerError, gin.H{"error": "internal error"})
		}
		return
	}
	c.JSON(http.StatusOK, u)
}

// cmd/main.go
func main() {

	ctx, cancel := context.WithCancel(context.Background())
	defer cancel()

	wg := &sync.WaitGroup{}

	router := gin.New()
	router.Use(gin.Recovery()) // gin.Default() adds an unstructured stdout logger — swap for your structured logger in prod

	container := app.NewAppContainer() // Creates all components, injecting respective databases
	routes.Register(router, container) // Registers all routes

	go server.Run(ctx, router, wg)

	sig := make(chan os.Signal, 1)
	signal.Notify(sig, syscall.SIGINT, syscall.SIGTERM)
	<-sig

	cancel()
	wg.Wait()
}

// Orchestrates component initialization and dependency injection
package app

type AppContainer struct {
	OrderComponent   orders.OrderComponent
	PaymentComponent payments.PaymentComponent
	UserComponent    users.UserComponent
}

func NewAppContainer() *AppContainer {
	return &AppContainer{
		OrderComponent: orders.NewOrderComponentImpl(orders.Deps{
			DB: db.InitMySQL(),
		}),
		PaymentComponent: payments.NewPaymentComponentImpl(payments.Deps{
			DB: db.InitPostgres(),
		}),
		UserComponent: users.NewUserComponentImpl(users.Deps{
			DB: db.InitMySQL(),
		}),
	}
}

// Orchestrates controllers
package routes

func Register(router *gin.Engine, container *app.AppContainer) {
	api := router.Group("/api")

	// Public (no auth)
	public := api.Group("/public")

	// Private (with auth middleware)
	private := api.Group("/private")
	private.Use(AuthMiddleware())

	// Payments
	paymentController := web.NewPaymentController(container.PaymentComponent)
	paymentController.RegisterRoutes(private.Group("/payments"))

	// Orders
	orderController := web.NewOrderController(container.OrderComponent)
	orderController.RegisterRoutes(public.Group("/orders"))

	// Users
	userController := web.NewUserController(container.UserComponent)
	userController.RegisterRoutes(private.Group("/users"))

	// Health
	api.GET("/health", func(c *gin.Context) {
		c.JSON(200, gin.H{"status": "ok"})
	})
}

// internal/payments/payment_component_impl.go (OLD)
func (s *PaymentService) Refund(ctx context.Context, userID string) error {
	u, err := s.userRepo.GetUser(ctx, userID)  // Direct access to users repo!
	if err != nil {
		return err
	}

	if u.CreditCard == nil {  // 💥 Internal field that changed 3 times
		return errors.New("no credit card")
	}
}

// contracts/user/service.go (NEW)
type Service interface {
	GetUserForPayment(ctx context.Context, id string) (PaymentUserDTO, error)  // Now the contract is explicit!
}

// internal/payments/service.go (NEW)
func (s *PaymentService) Refund(ctx context.Context, userID string) error {
	u, err := s.userService.GetUserForPayment(ctx, userID)  // Only what's NEEDED
	if err != nil {
		if errors.Is(err, user.ErrNotFound) {
			return fmt.Errorf("refund: user not eligible: %w", err)
		}
		return fmt.Errorf("refund: %w", err)
	}
	// ... refund logic
	return nil
}

// The whole mock — no database, no setup, no teardown:
type mockUserService struct {
	user user.UserDTO
	err  error
}

func (m *mockUserService) GetUserForPayment(_ context.Context, _ string) (user.UserDTO, error) {
	return m.user, m.err
}