Service-Based Architecture #

// ✓ Setiap service hanya akses tabel yang "dimilikinya"
// Kepemilikan tabel didefinisikan secara eksplisit

// User Service: pemilik tabel users, user_profiles, user_sessions
// Order Service: pemilik tabel orders, order_items, order_status_history
// Payment Service: pemilik tabel payments, payment_methods, refunds
// Notification Service: pemilik tabel notifications, notification_templates

// user-service/internal/repository/user_repo.go
package repository

// UserRepo hanya mengakses tabel yang dimiliki User Service
type UserRepo struct {
	db *sql.DB
}

func (r *UserRepo) FindByID(ctx context.Context, id string) (*User, error) {
	var u User
	err := r.db.QueryRowContext(ctx,
		`SELECT id, full_name, email, is_active FROM users WHERE id = $1`, id,
	).Scan(&u.ID, &u.FullName, &u.Email, &u.IsActive)
	return &u, err
}

// ✗ JANGAN: User Service mengakses tabel orders
func (r *UserRepo) GetUserOrders(ctx context.Context, userID string) ([]Order, error) {
	// ✗ Ini adalah coupling yang salah — User Service tidak memiliki tabel orders
	rows, _ := r.db.QueryContext(ctx,
		`SELECT id, total FROM orders WHERE user_id = $1`, userID,
	)
	_ = rows
	return nil, nil
}

// Strategi ownership tabel: definisikan secara eksplisit di dokumentasi dan kode

// db/ownership.go — package khusus untuk mendokumentasikan kepemilikan tabel
package db

// TableOwnership mendefinisikan service mana yang "memiliki" setiap tabel
// Service lain tidak boleh write ke tabel ini, dan sebaiknya tidak read langsung
var TableOwnership = map[string]string{
	"users":                   "user-service",
	"user_profiles":           "user-service",
	"user_sessions":           "user-service",
	"orders":                  "order-service",
	"order_items":             "order-service",
	"order_status_history":    "order-service",
	"payments":                "payment-service",
	"payment_methods":         "payment-service",
	"refunds":                 "payment-service",
	"notifications":           "notification-service",
	"notification_templates":  "notification-service",
}

// order-service/main.go
package main

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

	_ "github.com/lib/pq"
)

func main() {
	// Baca config dari environment variable — tiap service punya config sendiri
	dbURL := os.Getenv("DATABASE_URL")
	userServiceURL := os.Getenv("USER_SERVICE_URL")
	port := os.Getenv("PORT")
	if port == "" {
		port = "8082"
	}

	db, err := sql.Open("postgres", dbURL)
	if err != nil {
		log.Fatal("db connection failed:", err)
	}
	defer db.Close()

	// Inisialisasi layer — sama seperti monolith tapi per service
	repo := repository.NewOrderRepository(db)
	userClient := client.NewUserServiceClient(userServiceURL)
	svc := service.NewOrderService(repo, userClient)
	handler := handler.NewOrderHandler(svc)

	mux := http.NewServeMux()
	handler.RegisterRoutes(mux)

	log.Printf("Order Service berjalan di :%s", port)
	log.Fatal(http.ListenAndServe(":"+port, mux))
}

// order-service/internal/service/order_service.go
package service

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

// UserClient adalah interface untuk memanggil User Service
// ✓ Setiap service mendefinisikan interface untuk dependency-nya
type UserClient interface {
	ValidateActive(ctx context.Context, userID string) error
	GetName(ctx context.Context, userID string) (string, error)
}

// OrderRepository adalah interface data access
type OrderRepository interface {
	Save(ctx context.Context, order *Order) error
	FindByID(ctx context.Context, id string) (*Order, error)
	FindByUserID(ctx context.Context, userID string) ([]*Order, error)
	UpdateStatus(ctx context.Context, id string, status OrderStatus) error
}

type OrderService struct {
	repo       OrderRepository
	userClient UserClient
}

func NewOrderService(repo OrderRepository, userClient UserClient) *OrderService {
	return &OrderService{repo: repo, userClient: userClient}
}

// PlaceOrder adalah use case utama Order Service
func (s *OrderService) PlaceOrder(ctx context.Context, input PlaceOrderInput) (*OrderOutput, error) {
	// Validasi user via User Service — komunikasi antar service
	if err := s.userClient.ValidateActive(ctx, input.UserID); err != nil {
		return nil, errors.New("user tidak valid: " + err.Error())
	}

	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 := &Order{
		ID:         generateID(),
		UserID:     input.UserID,
		Status:     StatusPending,
		Items:      items,
		TotalCents: total,
		CreatedAt:  time.Now(),
	}

	// Simpan ke shared database — karena shared DB, bisa ACID
	if err := s.repo.Save(ctx, order); err != nil {
		return nil, err
	}

	return &OrderOutput{
		OrderID:    order.ID,
		Status:     string(order.Status),
		TotalCents: order.TotalCents,
	}, nil
}

// order-service/internal/client/user_client.go
// Client untuk memanggil User Service via HTTP
package client

import (
	"context"
	"encoding/json"
	"fmt"
	"net/http"
	"time"
)

type UserServiceClient struct {
	baseURL    string
	httpClient *http.Client
}

func NewUserServiceClient(baseURL string) *UserServiceClient {
	return &UserServiceClient{
		baseURL: baseURL,
		httpClient: &http.Client{
			Timeout: 3 * time.Second, // ✓ selalu ada timeout
		},
	}
}

type userResponse struct {
	ID       string `json:"id"`
	FullName string `json:"full_name"`
	IsActive bool   `json:"is_active"`
}

func (c *UserServiceClient) ValidateActive(ctx context.Context, userID string) error {
	req, err := http.NewRequestWithContext(ctx, http.MethodGet,
		fmt.Sprintf("%s/users/%s", c.baseURL, userID), nil)
	if err != nil {
		return err
	}

	resp, err := c.httpClient.Do(req)
	if err != nil {
		return fmt.Errorf("user service tidak tersedia: %w", err)
	}
	defer resp.Body.Close()

	if resp.StatusCode == http.StatusNotFound {
		return fmt.Errorf("user %s tidak ditemukan", userID)
	}
	if resp.StatusCode != http.StatusOK {
		return fmt.Errorf("user service error: status %d", resp.StatusCode)
	}

	var user userResponse
	if err := json.NewDecoder(resp.Body).Decode(&user); err != nil {
		return err
	}

	if !user.IsActive {
		return fmt.Errorf("user %s tidak aktif", userID)
	}
	return nil
}

func (c *UserServiceClient) GetName(ctx context.Context, userID string) (string, error) {
	req, _ := http.NewRequestWithContext(ctx, http.MethodGet,
		fmt.Sprintf("%s/users/%s", c.baseURL, userID), nil)
	resp, err := c.httpClient.Do(req)
	if err != nil {
		return "", err
	}
	defer resp.Body.Close()
	var user userResponse
	json.NewDecoder(resp.Body).Decode(&user)
	return user.FullName, nil
}

// order-service/internal/repository/order_repo.go
// Contoh: PlaceOrder + UpdateInventory dalam satu ACID transaction
// Ini TIDAK MUNGKIN di microservices tanpa saga yang kompleks

func (r *OrderRepository) PlaceOrderWithInventory(
	ctx context.Context,
	order *Order,
	productID string,
	quantity int,
) error {
	tx, err := r.db.BeginTx(ctx, nil)
	if err != nil {
		return err
	}
	defer tx.Rollback()

	// Insert order
	_, err = tx.ExecContext(ctx,
		`INSERT INTO orders (id, user_id, status, total_cents, created_at)
		 VALUES ($1, $2, $3, $4, NOW())`,
		order.ID, order.UserID, order.Status, order.TotalCents,
	)
	if err != nil {
		return fmt.Errorf("gagal insert order: %w", err)
	}

	// Update inventory — tabel milik "inventory domain" tapi dalam DB yang sama
	// ✓ Di SBA ini valid — satu DB, satu transaction
	result, err := tx.ExecContext(ctx,
		`UPDATE products SET stock = stock - $1
		 WHERE id = $2 AND stock >= $1`,
		quantity, productID,
	)
	if err != nil {
		return fmt.Errorf("gagal update inventory: %w", err)
	}

	rows, _ := result.RowsAffected()
	if rows == 0 {
		return errors.New("stok tidak cukup")
	}

	return tx.Commit()
}

// ✗ Service memanggil database service lain langsung
// order-service mengakses tabel milik user-service
func (r *OrderRepo) GetOrderWithUserDetails(ctx context.Context, orderID string) (*OrderDetail, error) {
	// ✗ ORDER service langsung JOIN ke tabel USER — coupling database langsung
	row := r.db.QueryRowContext(ctx, `
		SELECT o.id, o.total_cents, u.full_name, u.email
		FROM orders o
		JOIN users u ON u.id = o.user_id  -- ✗ tabel users bukan milik order-service
		WHERE o.id = $1
	`, orderID)
	_ = row
	return nil, nil
}

// ✓ Ambil data user via API, bukan via DB JOIN
func (s *OrderService) GetOrderWithUserDetails(ctx context.Context, orderID string) (*OrderDetail, error) {
	order, err := s.repo.FindByID(ctx, orderID)
	if err != nil {
		return nil, err
	}

	// ✓ Ambil data user dari User Service via HTTP API
	userName, err := s.userClient.GetName(ctx, order.UserID)
	if err != nil {
		userName = "Unknown" // ✓ graceful degradation
	}

	return &OrderDetail{
		OrderID:    order.ID,
		UserName:   userName,
		TotalCents: order.TotalCents,
	}, nil
}

// ✗ Tidak ada timeout pada inter-service call — goroutine menunggu selamanya
func (c *UserClient) GetUser(ctx context.Context, id string) (*User, error) {
	resp, err := http.Get(c.baseURL + "/users/" + id) // ✗ no timeout!
	_ = resp
	return nil, err
}

// ✓ Selalu ada timeout — baik di context maupun di http.Client
func (c *UserClient) GetUser(ctx context.Context, id string) (*User, error) {
	ctx, cancel := context.WithTimeout(ctx, 2*time.Second) // ✓ bounded wait
	defer cancel()

	req, _ := http.NewRequestWithContext(ctx, http.MethodGet, c.baseURL+"/users/"+id, nil)
	resp, err := c.http.Do(req)
	_ = resp
	return nil, err
}

// ✗ Service lain write langsung ke tabel milik service berbeda
// notification-service menulis langsung ke tabel orders
func (n *NotificationService) MarkOrderNotified(ctx context.Context, orderID string) error {
	// ✗ notification-service tidak boleh write ke tabel orders
	_, err := n.db.ExecContext(ctx,
		`UPDATE orders SET notified = TRUE WHERE id = $1`, orderID,
	)
	return err
}

// ✓ Gunakan API untuk meminta service pemilik melakukan update
func (n *NotificationService) MarkOrderNotified(ctx context.Context, orderID string) error {
	// ✓ Kirim request ke Order Service untuk update status notifikasi
	return n.orderClient.MarkNotified(ctx, orderID)
}