Modular Monolith Architecture #

// internal/user/api.go — public API modul User
// Ini adalah satu-satunya file yang boleh diimport oleh modul lain
package user

import "context"

// API adalah kontrak publik modul User
// ✓ Modul lain bergantung pada interface ini, bukan implementasinya
type API interface {
	GetByID(ctx context.Context, id string) (*UserDTO, error)
	ValidateActive(ctx context.Context, id string) error
	GetFullName(ctx context.Context, id string) (string, error)
}

// UserDTO adalah DTO yang dibagikan ke modul lain
// ✓ Bukan domain entity internal — hanya data transfer object
type UserDTO struct {
	ID       string
	FullName string
	Email    string
	IsActive bool
}

// Module adalah entry point modul User yang mengekspos API-nya
type Module struct {
	api     *service  // implementasi internal, tidak diekspos
	handler *handler
}

func NewModule(db *sql.DB) *Module {
	repo := newPostgresRepository(db)
	svc := newService(repo)
	h := newHandler(svc)
	return &Module{api: svc, handler: h}
}

// API mengembalikan implementasi API interface
// ✓ Tipe kembalian adalah interface, bukan *service
func (m *Module) API() API {
	return m.api
}

// RegisterRoutes mendaftarkan HTTP routes modul ini
func (m *Module) RegisterRoutes(mux *http.ServeMux) {
	mux.HandleFunc("POST /users", m.handler.create)
	mux.HandleFunc("GET /users/{id}", m.handler.getByID)
	mux.HandleFunc("PUT /users/{id}/deactivate", m.handler.deactivate)
}

// internal/user/service.go — implementasi internal, TIDAK diekspos ke modul lain
package user

import (
	"context"
	"errors"
	"time"
)

// service mengimplementasikan API interface
// Ini adalah detail implementasi internal modul User
type service struct {
	repo repository
}

func newService(repo repository) *service {
	return &service{repo: repo}
}

// GetByID mengimplementasikan API.GetByID
func (s *service) GetByID(ctx context.Context, id string) (*UserDTO, error) {
	u, err := s.repo.findByID(ctx, id)
	if err != nil {
		return nil, err
	}
	return &UserDTO{
		ID:       u.id,
		FullName: u.fullName,
		Email:    u.email,
		IsActive: u.isActive,
	}, nil
}

// ValidateActive mengimplementasikan API.ValidateActive
func (s *service) ValidateActive(ctx context.Context, id string) error {
	u, err := s.repo.findByID(ctx, id)
	if err != nil {
		return err
	}
	if !u.isActive {
		return errors.New("user tidak aktif")
	}
	return nil
}

func (s *service) GetFullName(ctx context.Context, id string) (string, error) {
	u, err := s.repo.findByID(ctx, id)
	if err != nil {
		return "", err
	}
	return u.fullName, nil
}

// user adalah domain entity INTERNAL — tidak diekspos ke luar
type user struct {
	id        string
	fullName  string
	email     string
	isActive  bool
	createdAt time.Time
}

func (u *user) deactivate() error {
	if !u.isActive {
		return errors.New("user sudah tidak aktif")
	}
	u.isActive = false
	return nil
}

// internal/shared/eventbus/eventbus.go — shared component
package eventbus

import (
	"context"
	"fmt"
	"sync"
)

// Event adalah interface untuk semua domain event
type Event interface {
	EventName() string
}

// Handler adalah fungsi yang menangani event
type Handler func(ctx context.Context, event Event) error

// EventBus adalah in-process event bus untuk komunikasi antar modul
type EventBus struct {
	mu       sync.RWMutex
	handlers map[string][]Handler
}

func New() *EventBus {
	return &EventBus{
		handlers: make(map[string][]Handler),
	}
}

// Subscribe mendaftarkan handler untuk event tertentu
func (b *EventBus) Subscribe(eventName string, handler Handler) {
	b.mu.Lock()
	defer b.mu.Unlock()
	b.handlers[eventName] = append(b.handlers[eventName], handler)
}

// Publish mempublikasikan event ke semua subscriber
// ✓ Publisher tidak tahu siapa subscribernya
func (b *EventBus) Publish(ctx context.Context, event Event) error {
	b.mu.RLock()
	handlers := b.handlers[event.EventName()]
	b.mu.RUnlock()

	var errs []error
	for _, handler := range handlers {
		if err := handler(ctx, event); err != nil {
			errs = append(errs, err)
		}
	}
	if len(errs) > 0 {
		return fmt.Errorf("%d handler gagal memproses event %s", len(errs), event.EventName())
	}
	return nil
}

// internal/order/events.go — domain events yang dipublikasikan oleh Order module
package order

import "time"

// OrderPlacedEvent dipublikasikan ketika order berhasil dibuat
// ✓ Modul lain (notification, inventory) subscribe ke event ini
type OrderPlacedEvent struct {
	OrderID    string
	CustomerID string
	TotalCents int64
	Items      []OrderItemEvent
	OccurredAt time.Time
}

type OrderItemEvent struct {
	ProductID string
	Quantity  int
}

func (e OrderPlacedEvent) EventName() string { return "order.placed" }

// OrderCancelledEvent dipublikasikan ketika order dibatalkan
type OrderCancelledEvent struct {
	OrderID    string
	CustomerID string
	Reason     string
	OccurredAt time.Time
}

func (e OrderCancelledEvent) EventName() string { return "order.cancelled" }

// internal/order/service.go — Order module menggunakan User API dan EventBus
package order

import (
	"context"
	"errors"
	"time"

	"myapp/internal/shared/eventbus"
	"myapp/internal/user" // ✓ hanya import package user untuk tipenya
)

type Service struct {
	repo     Repository
	userAPI  user.API       // ✓ interface dari modul User, bukan struct konkret
	eventBus *eventbus.EventBus
}

func NewService(repo Repository, userAPI user.API, bus *eventbus.EventBus) *Service {
	return &Service{repo: repo, userAPI: userAPI, eventBus: bus}
}

type PlaceOrderInput struct {
	CustomerID string
	Items      []PlaceOrderItem
}

type PlaceOrderItem struct {
	ProductID  string
	Quantity   int
	PriceCents int64
}

func (s *Service) PlaceOrder(ctx context.Context, input PlaceOrderInput) (*Order, error) {
	// Validasi customer via User module API
	if err := s.userAPI.ValidateActive(ctx, input.CustomerID); err != nil {
		return nil, errors.New("customer tidak valid: " + err.Error())
	}

	// Buat order
	order := &Order{
		ID:         generateID(),
		CustomerID: input.CustomerID,
		Status:     StatusPending,
		CreatedAt:  time.Now(),
	}

	total := int64(0)
	items := make([]OrderItem, len(input.Items))
	for i, item := range input.Items {
		items[i] = OrderItem{
			ProductID:  item.ProductID,
			Quantity:   item.Quantity,
			PriceCents: item.PriceCents,
		}
		total += item.PriceCents * int64(item.Quantity)
	}
	order.Items = items
	order.TotalCents = total

	if err := s.repo.Save(ctx, order); err != nil {
		return nil, err
	}

	// Publikasikan event — Notification dan Inventory module akan merespons
	// ✓ Order tidak tahu siapa yang subscribe
	eventItems := make([]OrderItemEvent, len(items))
	for i, item := range items {
		eventItems[i] = OrderItemEvent{ProductID: item.ProductID, Quantity: item.Quantity}
	}
	_ = s.eventBus.Publish(ctx, OrderPlacedEvent{
		OrderID:    order.ID,
		CustomerID: order.CustomerID,
		TotalCents: order.TotalCents,
		Items:      eventItems,
		OccurredAt: time.Now(),
	})

	return order, nil
}

// internal/notification/module.go — Notification module subscribe ke Order events
package notification

import (
	"context"
	"fmt"

	"myapp/internal/order"
	"myapp/internal/shared/eventbus"
	"myapp/internal/user"
)

type Module struct {
	userAPI user.API
	bus     *eventbus.EventBus
}

func NewModule(userAPI user.API, bus *eventbus.EventBus) *Module {
	m := &Module{userAPI: userAPI, bus: bus}
	m.registerHandlers()
	return m
}

// registerHandlers mendaftarkan semua event handler
// ✓ Notification subscribe ke event dari modul lain tanpa coupling langsung
func (m *Module) registerHandlers() {
	m.bus.Subscribe("order.placed", m.handleOrderPlaced)
	m.bus.Subscribe("order.cancelled", m.handleOrderCancelled)
}

func (m *Module) handleOrderPlaced(ctx context.Context, event eventbus.Event) error {
	e, ok := event.(order.OrderPlacedEvent)
	if !ok {
		return fmt.Errorf("unexpected event type")
	}

	// Ambil nama customer dari User module
	fullName, err := m.userAPI.GetFullName(ctx, e.CustomerID)
	if err != nil {
		return err
	}

	// Kirim notifikasi
	fmt.Printf("[Notification] Order %s dibuat oleh %s, total: Rp%.2f\n",
		e.OrderID, fullName, float64(e.TotalCents)/100)
	return nil
}

func (m *Module) handleOrderCancelled(ctx context.Context, event eventbus.Event) error {
	e, ok := event.(order.OrderCancelledEvent)
	if !ok {
		return fmt.Errorf("unexpected event type")
	}
	fmt.Printf("[Notification] Order %s dibatalkan: %s\n", e.OrderID, e.Reason)
	return nil
}

-- Migration: setiap modul punya schema sendiri
CREATE SCHEMA IF NOT EXISTS user_module;
CREATE SCHEMA IF NOT EXISTS order_module;
CREATE SCHEMA IF NOT EXISTS payment_module;
CREATE SCHEMA IF NOT EXISTS notification_module;

-- Tabel User hanya di user_module schema
CREATE TABLE user_module.users (
    id UUID PRIMARY KEY,
    full_name VARCHAR(200) NOT NULL,
    email VARCHAR(255) UNIQUE NOT NULL,
    is_active BOOLEAN DEFAULT TRUE,
    created_at TIMESTAMP DEFAULT NOW()
);

-- Tabel Order hanya di order_module schema
CREATE TABLE order_module.orders (
    id UUID PRIMARY KEY,
    customer_id UUID NOT NULL, -- reference ke user, tapi TANPA foreign key constraint
    status VARCHAR(50) NOT NULL,
    total_cents BIGINT NOT NULL,
    created_at TIMESTAMP DEFAULT NOW()
);

-- ✗ Tidak ada cross-schema JOIN:
-- SELECT o.*, u.full_name FROM order_module.orders o
-- JOIN user_module.users u ON u.id = o.customer_id  ← JANGAN

-- ✓ Data dari modul lain diambil via API call, bukan JOIN

// internal/order/internal/domain/order.go
// ✓ Sub-package "internal" hanya bisa diakses dalam package order
// Compiler Go mencegah import dari luar
package domain

// Order adalah entity internal modul — tidak bisa diakses dari luar order module
type Order struct {
	id         string
	customerID string
	status     Status
	items      []Item
}

// Verifikasi dependency antar modul dengan go build tag
// Buat file: internal/order/check_deps_test.go

//go:build deps_check

package order_test

import (
	// ✓ Boleh: import shared package
	_ "myapp/internal/shared/eventbus"

	// ✓ Boleh: import public API modul lain
	_ "myapp/internal/user"

	// ✗ Tidak boleh: import internal package modul lain
	// _ "myapp/internal/user/internal/domain"  ← compiler error
	// _ "myapp/internal/payment/service"       ← compiler error
)

# Install
go install github.com/roblaszczak/go-cleanarch@latest

# Jalankan validasi — gagal jika ada dependency yang melanggar aturan
go-cleanarch -application myapp/internal

# Integrasikan ke CI/CD
# .github/workflows/ci.yml:
# - name: Check architecture
#   run: go-cleanarch -application ./internal

// cmd/server/main.go
package main

import (
	"database/sql"
	"log"
	"net/http"

	_ "github.com/lib/pq"

	"myapp/internal/notification"
	"myapp/internal/order"
	"myapp/internal/payment"
	"myapp/internal/shared/eventbus"
	"myapp/internal/user"
)

func main() {
	db, err := sql.Open("postgres", "postgres://localhost/myapp?sslmode=disable")
	if err != nil {
		log.Fatal(err)
	}
	defer db.Close()

	// Shared event bus — satu untuk seluruh aplikasi
	bus := eventbus.New()

	// Inisialisasi modul — setiap modul hanya menerima dependency yang ia butuhkan
	userModule := user.NewModule(db)
	orderModule := order.NewModule(db, userModule.API(), bus)
	paymentModule := payment.NewModule(db, orderModule.API(), bus)
	notificationModule := notification.NewModule(userModule.API(), bus)

	// Semua modul siap — notification sudah subscribe ke events via konstruktor

	// Setup router
	mux := http.NewServeMux()
	userModule.RegisterRoutes(mux)
	orderModule.RegisterRoutes(mux)
	paymentModule.RegisterRoutes(mux)
	// notification tidak punya HTTP routes — hanya event subscriber

	_ = notificationModule // tetap dalam scope agar tidak di-GC

	log.Println("Modular monolith berjalan di :8080")
	log.Fatal(http.ListenAndServe(":8080", mux))
}

// ✗ Import langsung ke internal modul lain
package order

import "myapp/internal/user/service" // ✗ import internal package user

func (s *Service) PlaceOrder(customerID string) error {
	// ✗ mengakses implementasi internal user module
	userSvc := service.NewUserService(s.db)
	user, _ := userSvc.FindByID(customerID)
	_ = user
	return nil
}

// ✓ Gunakan API interface yang diekspos modul
package order

func (s *Service) PlaceOrder(ctx context.Context, customerID string) error {
	// ✓ hanya menggunakan public API interface
	if err := s.userAPI.ValidateActive(ctx, customerID); err != nil {
		return err
	}
	return nil
}

// ✗ Cross-schema database JOIN
// repository.go di order module
func (r *repo) GetOrdersWithUserName(ctx context.Context) ([]OrderWithUser, error) {
	// ✗ JOIN ke tabel user_module — melanggar schema isolation
	return r.db.QueryContext(ctx, `
		SELECT o.id, o.total_cents, u.full_name
		FROM order_module.orders o
		JOIN user_module.users u ON u.id = o.customer_id
	`)
}

// ✓ Ambil data dari modul lain via API, tidak via JOIN
func (s *Service) GetOrdersWithUserName(ctx context.Context) ([]OrderDisplay, error) {
	orders, err := s.repo.FindAll(ctx)
	if err != nil {
		return nil, err
	}

	result := make([]OrderDisplay, len(orders))
	for i, order := range orders {
		name, _ := s.userAPI.GetFullName(ctx, order.CustomerID) // ✓ via API
		result[i] = OrderDisplay{OrderID: order.ID, CustomerName: name}
	}
	return result, nil
}

// ✗ Shared mutable state di event handler — race condition
var processedEvents = map[string]bool{} // ✗ shared tanpa lock

func handleEvent(ctx context.Context, event eventbus.Event) error {
	processedEvents[event.EventName()] = true // ✗ data race
	return nil
}

// ✓ Gunakan sync.Map atau hindari shared state di event handler
var processed sync.Map

func handleEventSafe(ctx context.Context, event eventbus.Event) error {
	processed.Store(event.EventName(), true) // ✓ thread-safe
	return nil
}