Hexagonal Architecture #

// port/inbound/create_order.go
// Inbound Port: didefinisikan oleh application core
// Actor eksternal (HTTP, CLI, gRPC) memanggil melalui interface ini
package inbound

import "context"

// CreateOrderRequest adalah input DTO yang framework-agnostic
type CreateOrderRequest struct {
	CustomerID string
	Items      []CreateOrderItem
}

type CreateOrderItem struct {
	ProductID string
	Quantity  int
	PriceCents int64
}

type CreateOrderResponse struct {
	OrderID    string
	TotalCents int64
	Status     string
}

// CreateOrderPort adalah inbound port — kontrak yang ditawarkan core ke dunia luar
type CreateOrderPort interface {
	CreateOrder(ctx context.Context, req CreateOrderRequest) (*CreateOrderResponse, error)
}

// application/create_order_service.go
// Application Service mengimplementasikan inbound port
package application

import (
	"context"
	"errors"

	"myapp/domain"
	"myapp/port/inbound"
	"myapp/port/outbound"
)

// CreateOrderService mengimplementasikan inbound.CreateOrderPort
// ✓ Ia tidak tahu apakah dipanggil dari HTTP, CLI, atau gRPC
type CreateOrderService struct {
	orderRepo    outbound.OrderRepository  // outbound port
	inventory    outbound.InventoryChecker // outbound port
	eventBus     outbound.EventPublisher   // outbound port
}

func NewCreateOrderService(
	orderRepo outbound.OrderRepository,
	inventory outbound.InventoryChecker,
	eventBus outbound.EventPublisher,
) *CreateOrderService {
	return &CreateOrderService{
		orderRepo: orderRepo,
		inventory: inventory,
		eventBus:  eventBus,
	}
}

// CreateOrder mengimplementasikan inbound.CreateOrderPort
func (s *CreateOrderService) CreateOrder(
	ctx context.Context,
	req inbound.CreateOrderRequest,
) (*inbound.CreateOrderResponse, error) {
	if req.CustomerID == "" {
		return nil, errors.New("customer ID wajib diisi")
	}

	// Bangun domain object dari request
	items := make([]domain.OrderItem, len(req.Items))
	for i, item := range req.Items {
		items[i] = domain.OrderItem{
			ProductID: domain.ProductID(item.ProductID),
			Quantity:  item.Quantity,
			Price:     domain.Money{Cents: item.PriceCents},
		}
	}

	// Cek stok via outbound port
	if err := s.inventory.CheckAvailability(ctx, items); err != nil {
		return nil, err
	}

	// Buat domain entity
	order, err := domain.NewOrder(domain.CustomerID(req.CustomerID), items)
	if err != nil {
		return nil, err
	}

	// Simpan via outbound port
	if err := s.orderRepo.Save(ctx, order); err != nil {
		return nil, err
	}

	// Publikasikan event via outbound port
	for _, event := range order.PullEvents() {
		_ = s.eventBus.Publish(ctx, event)
	}

	return &inbound.CreateOrderResponse{
		OrderID:    string(order.ID()),
		TotalCents: order.Total().Cents,
		Status:     string(order.Status()),
	}, nil
}

// adapter/inbound/http/order_handler.go
// HTTP Inbound Adapter: menerjemahkan HTTP request ke inbound port
package http

import (
	"encoding/json"
	"net/http"

	"myapp/port/inbound"
)

// OrderHandler adalah inbound adapter untuk HTTP
// ✓ Ia hanya menerjemahkan HTTP → inbound port, tidak ada business logic
type OrderHandler struct {
	createOrder inbound.CreateOrderPort
}

func NewOrderHandler(createOrder inbound.CreateOrderPort) *OrderHandler {
	return &OrderHandler{createOrder: createOrder}
}

type createOrderHTTPRequest struct {
	CustomerID string          `json:"customer_id"`
	Items      []orderItemHTTP `json:"items"`
}

type orderItemHTTP struct {
	ProductID string `json:"product_id"`
	Quantity  int    `json:"quantity"`
	Price     int64  `json:"price"`
}

func (h *OrderHandler) CreateOrder(w http.ResponseWriter, r *http.Request) {
	var httpReq createOrderHTTPRequest
	if err := json.NewDecoder(r.Body).Decode(&httpReq); err != nil {
		http.Error(w, "request tidak valid", http.StatusBadRequest)
		return
	}

	// Map HTTP request → inbound port request
	portReq := inbound.CreateOrderRequest{
		CustomerID: httpReq.CustomerID,
		Items:      make([]inbound.CreateOrderItem, len(httpReq.Items)),
	}
	for i, item := range httpReq.Items {
		portReq.Items[i] = inbound.CreateOrderItem{
			ProductID:  item.ProductID,
			Quantity:   item.Quantity,
			PriceCents: item.Price,
		}
	}

	// Panggil inbound port — tidak tahu implementasinya
	resp, err := h.createOrder.CreateOrder(r.Context(), portReq)
	if err != nil {
		http.Error(w, err.Error(), http.StatusUnprocessableEntity)
		return
	}

	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(http.StatusCreated)
	json.NewEncoder(w).Encode(resp)
}

// port/outbound/repository.go
// Outbound Ports: didefinisikan oleh core, diimplementasikan oleh adapter
package outbound

import (
	"context"

	"myapp/domain"
)

// OrderRepository adalah outbound port untuk persistence
// ✓ Didefinisikan di sisi core, bukan di sisi database
type OrderRepository interface {
	Save(ctx context.Context, order *domain.Order) error
	FindByID(ctx context.Context, id domain.OrderID) (*domain.Order, error)
	FindByCustomer(ctx context.Context, customerID domain.CustomerID) ([]*domain.Order, error)
}

// InventoryChecker adalah outbound port untuk cek ketersediaan stok
type InventoryChecker interface {
	CheckAvailability(ctx context.Context, items []domain.OrderItem) error
}

// EventPublisher adalah outbound port untuk publikasi domain event
type EventPublisher interface {
	Publish(ctx context.Context, event domain.DomainEvent) error
}

// EmailSender adalah outbound port untuk pengiriman email
type EmailSender interface {
	Send(ctx context.Context, to, subject, body string) error
}

// adapter/outbound/postgres/order_repository.go
// PostgreSQL Outbound Adapter: mengimplementasikan outbound.OrderRepository
package postgres

import (
	"context"
	"database/sql"
	"fmt"

	"myapp/domain"
	"myapp/port/outbound"
)

// PostgresOrderRepository adalah adapter PostgreSQL untuk outbound.OrderRepository
// ✓ Hanya ini yang tahu tentang SQL — core tidak perlu tahu
type PostgresOrderRepository struct {
	db *sql.DB
}

// Pastikan PostgresOrderRepository mengimplementasikan interface dengan benar
var _ outbound.OrderRepository = (*PostgresOrderRepository)(nil)

func NewPostgresOrderRepository(db *sql.DB) *PostgresOrderRepository {
	return &PostgresOrderRepository{db: db}
}

func (r *PostgresOrderRepository) Save(ctx context.Context, order *domain.Order) error {
	tx, err := r.db.BeginTx(ctx, nil)
	if err != nil {
		return fmt.Errorf("gagal mulai transaksi: %w", err)
	}
	defer tx.Rollback()

	_, err = tx.ExecContext(ctx,
		`INSERT INTO orders (id, customer_id, status, total_cents, created_at)
		 VALUES ($1, $2, $3, $4, NOW())
		 ON CONFLICT (id) DO UPDATE
		 SET status = $3, total_cents = $4`,
		string(order.ID()), string(order.CustomerID()),
		string(order.Status()), order.Total().Cents,
	)
	if err != nil {
		return fmt.Errorf("gagal menyimpan order: %w", err)
	}

	return tx.Commit()
}

func (r *PostgresOrderRepository) FindByID(
	ctx context.Context,
	id domain.OrderID,
) (*domain.Order, error) {
	// implementasi query...
	return nil, nil
}

func (r *PostgresOrderRepository) FindByCustomer(
	ctx context.Context,
	customerID domain.CustomerID,
) ([]*domain.Order, error) {
	// implementasi query...
	return nil, nil
}

// adapter/outbound/sendgrid/email_sender.go
// SendGrid Outbound Adapter: mengimplementasikan outbound.EmailSender
package sendgrid

import (
	"context"
	"fmt"
)

// SendGridEmailSender adalah adapter SendGrid
// ✓ Mengganti vendor email hanya berarti mengganti adapter ini
type SendGridEmailSender struct {
	apiKey    string
	fromEmail string
}

var _ outbound.EmailSender = (*SendGridEmailSender)(nil)

func NewSendGridEmailSender(apiKey, fromEmail string) *SendGridEmailSender {
	return &SendGridEmailSender{apiKey: apiKey, fromEmail: fromEmail}
}

func (s *SendGridEmailSender) Send(ctx context.Context, to, subject, body string) error {
	// Panggil SendGrid API...
	fmt.Printf("[SendGrid] Mengirim ke %s: %s\n", to, subject)
	return nil
}

// application/create_order_service_test.go
package application_test

import (
	"context"
	"testing"

	"myapp/application"
	"myapp/domain"
	"myapp/port/inbound"
)

// Mock adapter untuk OrderRepository
type mockOrderRepository struct {
	savedOrders []*domain.Order
	shouldFail  bool
}

func (m *mockOrderRepository) Save(ctx context.Context, order *domain.Order) error {
	if m.shouldFail {
		return errors.New("database error")
	}
	m.savedOrders = append(m.savedOrders, order)
	return nil
}

func (m *mockOrderRepository) FindByID(ctx context.Context, id domain.OrderID) (*domain.Order, error) {
	return nil, nil
}

func (m *mockOrderRepository) FindByCustomer(ctx context.Context, customerID domain.CustomerID) ([]*domain.Order, error) {
	return nil, nil
}

// Mock adapter untuk InventoryChecker
type mockInventory struct {
	available bool
}

func (m *mockInventory) CheckAvailability(ctx context.Context, items []domain.OrderItem) error {
	if !m.available {
		return errors.New("stok tidak cukup")
	}
	return nil
}

// Mock adapter untuk EventPublisher
type mockEventPublisher struct {
	publishedEvents []domain.DomainEvent
}

func (m *mockEventPublisher) Publish(ctx context.Context, event domain.DomainEvent) error {
	m.publishedEvents = append(m.publishedEvents, event)
	return nil
}

// Test: menguji CreateOrderService tanpa database, HTTP, atau Kafka nyata
func TestCreateOrderService_Success(t *testing.T) {
	repo := &mockOrderRepository{}
	inventory := &mockInventory{available: true}
	events := &mockEventPublisher{}

	// ✓ Menggunakan mock adapter — tidak butuh PostgreSQL atau Kafka
	svc := application.NewCreateOrderService(repo, inventory, events)

	resp, err := svc.CreateOrder(context.Background(), inbound.CreateOrderRequest{
		CustomerID: "cust-123",
		Items: []inbound.CreateOrderItem{
			{ProductID: "prod-1", Quantity: 2, PriceCents: 50000},
		},
	})

	if err != nil {
		t.Fatalf("tidak mengharapkan error, dapat: %v", err)
	}
	if resp.OrderID == "" {
		t.Error("order ID tidak boleh kosong")
	}
	if resp.TotalCents != 100000 {
		t.Errorf("total seharusnya 100000, dapat %d", resp.TotalCents)
	}
	if len(repo.savedOrders) != 1 {
		t.Errorf("seharusnya 1 order tersimpan, dapat %d", len(repo.savedOrders))
	}
	if len(events.publishedEvents) == 0 {
		t.Error("seharusnya ada event yang dipublikasikan")
	}
}

func TestCreateOrderService_OutOfStock(t *testing.T) {
	repo := &mockOrderRepository{}
	inventory := &mockInventory{available: false} // ✓ simulasi stok habis
	events := &mockEventPublisher{}

	svc := application.NewCreateOrderService(repo, inventory, events)

	_, err := svc.CreateOrder(context.Background(), inbound.CreateOrderRequest{
		CustomerID: "cust-123",
		Items: []inbound.CreateOrderItem{
			{ProductID: "prod-1", Quantity: 999, PriceCents: 50000},
		},
	})

	if err == nil {
		t.Error("seharusnya error saat stok habis")
	}
	if len(repo.savedOrders) != 0 {
		t.Error("order tidak boleh disimpan saat stok habis")
	}
}

// Test menggunakan inbound adapter CLI langsung — tanpa HTTP server
func TestCreateOrder_ViaDirectPort(t *testing.T) {
	// ✓ Test suite bisa memanggil inbound port langsung — tidak butuh HTTP server
	var svc inbound.CreateOrderPort = application.NewCreateOrderService(
		&mockOrderRepository{},
		&mockInventory{available: true},
		&mockEventPublisher{},
	)

	_, err := svc.CreateOrder(context.Background(), inbound.CreateOrderRequest{
		CustomerID: "cust-456",
		Items: []inbound.CreateOrderItem{
			{ProductID: "prod-2", Quantity: 1, PriceCents: 75000},
		},
	})

	if err != nil {
		t.Fatalf("tidak mengharapkan error: %v", err)
	}
}

// Sebelum: menggunakan PostgreSQL
pgRepo := postgres.NewPostgresOrderRepository(postgresDB)

// Sesudah: migrasi ke MongoDB — hanya ganti adapter
// ✓ Application service tidak berubah sama sekali
mongoRepo := mongodb.NewMongoOrderRepository(mongoClient)

// Wiring di main.go — satu-satunya file yang berubah
svc := application.NewCreateOrderService(
	mongoRepo,   // ← ganti ini
	inventoryChecker,
	eventPublisher,
)

// ✗ Domain mengimport adapter — pelanggaran paling fundamental
package domain

import "myapp/adapter/outbound/postgres" // ✗ domain tidak boleh tahu tentang postgres

type OrderService struct {
    repo *postgres.PostgresOrderRepository // ✗ dependency ke adapter konkret
}

// ✓ Domain hanya tahu tentang port (interface)
package domain

import "myapp/port/outbound" // ✓ hanya interface

type OrderService struct {
    repo outbound.OrderRepository // ✓ dependency ke interface
}

// ✗ Business logic di adapter — adapter seharusnya hanya menerjemahkan
func (h *OrderHandler) CreateOrder(w http.ResponseWriter, r *http.Request) {
    // ✗ validasi bisnis di HTTP handler
    if req.Quantity > 100 {
        http.Error(w, "quantity terlalu banyak", http.StatusBadRequest)
        return
    }
    // ✗ kalkulasi harga di HTTP adapter
    total := req.Quantity * req.Price * 0.9 // diskon 10%
    // ...
}

// ✓ Adapter tipis — hanya parse, delegate, format
func (h *OrderHandler) CreateOrder(w http.ResponseWriter, r *http.Request) {
    var req createOrderHTTPRequest
    json.NewDecoder(r.Body).Decode(&req)
    resp, err := h.createOrder.CreateOrder(r.Context(), mapToPortRequest(req)) // ✓
    if err != nil {
        http.Error(w, err.Error(), http.StatusUnprocessableEntity)
        return
    }
    json.NewEncoder(w).Encode(resp)
}

// ✗ Outbound port didefinisikan di sisi adapter — pelanggaran ownership
// adapter/outbound/postgres/repository.go
package postgres

type OrderRepository interface { // ✗ interface di sisi implementasi
    Save(order *Order) error
}

// ✓ Outbound port didefinisikan di sisi core — core yang menentukan kebutuhan
// port/outbound/repository.go
package outbound

type OrderRepository interface { // ✓ interface di sisi core
    Save(ctx context.Context, order *domain.Order) error
}