Mediator Pattern #

// ANTI-PATTERN: setiap komponen menyimpan referensi ke komponen lain

type InventoryComponent struct {
    priceComp   *PriceComponent   // tahu tentang price
    orderComp   *OrderComponent   // tahu tentang order
    notifComp   *NotifComponent   // tahu tentang notifikasi
}

func (ic *InventoryComponent) OnStockUpdate(productID string, qty int) {
    // Harus tahu cara update setiap komponen lain secara langsung
    ic.priceComp.RecalculateForProduct(productID)
    if qty == 0 {
        ic.priceComp.MarkOutOfStock(productID)
        ic.orderComp.BlockNewOrders(productID)
        ic.notifComp.NotifySubscribers(productID, "out_of_stock")
    }
}

// Setiap komponen punya ketergantungan ke semua komponen lain
// Menambah komponen baru = update semua komponen yang perlu tahu tentangnya

// BENAR: setiap komponen hanya tahu mediator
type InventoryComponent struct {
    mediator Mediator
}

func (ic *InventoryComponent) OnStockUpdate(productID string, qty int) {
    ic.mediator.Notify(ic, "stock_updated", map[string]interface{}{
        "product_id": productID,
        "quantity":   qty,
    })
    // Komponen tidak tahu siapa yang akan bereaksi atau bagaimana
}

package chat

import (
    "fmt"
    "strings"
    "time"
)

// Mediator adalah interface untuk semua chatroom mediator.
type Mediator interface {
    SendMessage(sender *User, message string)
    SendPrivateMessage(sender *User, recipientName, message string) error
    Register(user *User)
    Unregister(username string)
    ListUsers() []string
}

// User adalah Colleague — berkomunikasi melalui mediator, tidak langsung ke user lain.
type User struct {
    Name      string
    mediator  Mediator
    inbox     []Message
}

// Message merepresentasikan satu pesan dalam chatroom.
type Message struct {
    From      string
    To        string // kosong = broadcast
    Content   string
    SentAt    time.Time
    IsPrivate bool
}

func NewUser(name string) *User {
    return &User{
        Name:  name,
        inbox: make([]Message, 0),
    }
}

// SetMediator mendaftarkan mediator ke user.
func (u *User) SetMediator(m Mediator) {
    u.mediator = m
    m.Register(u)
}

// Send mengirim pesan ke semua user dalam chatroom.
func (u *User) Send(message string) {
    u.mediator.SendMessage(u, message)
}

// SendTo mengirim pesan pribadi ke user tertentu.
func (u *User) SendTo(recipientName, message string) error {
    return u.mediator.SendPrivateMessage(u, recipientName, message)
}

// Receive dipanggil oleh mediator ketika ada pesan yang masuk.
// User tidak memanggil ini sendiri — ini adalah "callback" dari mediator.
func (u *User) Receive(msg Message) {
    u.inbox = append(u.inbox, msg)
    if msg.IsPrivate {
        fmt.Printf("[DM to %s] %s → %s: %s\n", u.Name, msg.From, u.Name, msg.Content)
    } else {
        fmt.Printf("[%s] %s: %s\n", u.Name, msg.From, msg.Content)
    }
}

// Inbox mengembalikan semua pesan yang diterima user.
func (u *User) Inbox() []Message { return u.inbox }

package chat

import (
    "fmt"
    "sync"
    "time"
)

// ChatRoom adalah Concrete Mediator — mengatur semua komunikasi antar user.
type ChatRoom struct {
    mu    sync.RWMutex
    users map[string]*User
    log   []Message
}

func NewChatRoom() *ChatRoom {
    return &ChatRoom{
        users: make(map[string]*User),
        log:   make([]Message, 0),
    }
}

// Register mendaftarkan user baru ke chatroom.
func (c *ChatRoom) Register(user *User) {
    c.mu.Lock()
    defer c.mu.Unlock()

    c.users[user.Name] = user
    fmt.Printf("[ChatRoom] %s bergabung. Total user: %d\n", user.Name, len(c.users))

    // Beritahu user lain bahwa ada user baru
    joinMsg := Message{
        From:    "ChatRoom",
        Content: fmt.Sprintf("%s bergabung ke chatroom", user.Name),
        SentAt:  time.Now(),
    }
    for name, u := range c.users {
        if name != user.Name {
            u.Receive(joinMsg)
        }
    }
}

// Unregister menghapus user dari chatroom.
func (c *ChatRoom) Unregister(username string) {
    c.mu.Lock()
    defer c.mu.Unlock()

    delete(c.users, username)
    fmt.Printf("[ChatRoom] %s keluar. Total user: %d\n", username, len(c.users))

    leaveMsg := Message{
        From:    "ChatRoom",
        Content: fmt.Sprintf("%s keluar dari chatroom", username),
        SentAt:  time.Now(),
    }
    for _, u := range c.users {
        u.Receive(leaveMsg)
    }
}

// SendMessage membroadcast pesan ke semua user kecuali pengirim.
// Ini adalah inti koordinasi mediator.
func (c *ChatRoom) SendMessage(sender *User, content string) {
    c.mu.RLock()
    defer c.mu.RUnlock()

    msg := Message{
        From:    sender.Name,
        Content: content,
        SentAt:  time.Now(),
    }
    c.log = append(c.log, msg)

    // Kirim ke semua user KECUALI pengirim
    for name, user := range c.users {
        if name != sender.Name {
            user.Receive(msg)
        }
    }
}

// SendPrivateMessage mengirim pesan hanya ke satu user tertentu.
func (c *ChatRoom) SendPrivateMessage(sender *User, recipientName, content string) error {
    c.mu.RLock()
    defer c.mu.RUnlock()

    recipient, ok := c.users[recipientName]
    if !ok {
        return fmt.Errorf("user %q tidak ditemukan dalam chatroom", recipientName)
    }

    msg := Message{
        From:      sender.Name,
        To:        recipientName,
        Content:   content,
        SentAt:    time.Now(),
        IsPrivate: true,
    }
    c.log = append(c.log, msg)
    recipient.Receive(msg)
    return nil
}

// ListUsers mengembalikan daftar username yang aktif.
func (c *ChatRoom) ListUsers() []string {
    c.mu.RLock()
    defer c.mu.RUnlock()
    names := make([]string, 0, len(c.users))
    for name := range c.users {
        names = append(names, name)
    }
    return names
}

// MessageLog mengembalikan seluruh log pesan.
func (c *ChatRoom) MessageLog() []Message {
    c.mu.RLock()
    defer c.mu.RUnlock()
    result := make([]Message, len(c.log))
    copy(result, c.log)
    return result
}

func main() {
    room := chat.NewChatRoom()

    alice := chat.NewUser("Alice")
    bob   := chat.NewUser("Bob")
    citra := chat.NewUser("Citra")

    // Daftarkan ke chatroom — user tidak saling tahu satu sama lain
    alice.SetMediator(room)
    bob.SetMediator(room)
    citra.SetMediator(room)

    fmt.Println("\n--- Pesan Broadcast ---")
    alice.Send("Halo semua!")
    bob.Send("Hai Alice!")

    fmt.Println("\n--- Pesan Privat ---")
    _ = alice.SendTo("Citra", "Hai Citra, ada waktu ngobrol?")
    _ = bob.SendTo("NonExistent", "test") // error — user tidak ada

    fmt.Printf("\nTotal user: %v\n", room.ListUsers())
    fmt.Printf("Alice inbox: %d pesan\n", len(alice.Inbox()))
}

package workflow

import (
    "context"
    "fmt"
    "log/slog"
)

// WorkflowStep adalah Colleague — satu langkah dalam workflow.
type WorkflowStep interface {
    Execute(ctx context.Context, data map[string]interface{}) error
    StepName() string
    SetCoordinator(coordinator WorkflowCoordinator)
}

// WorkflowCoordinator adalah Mediator — mengatur urutan dan kondisi eksekusi step.
type WorkflowCoordinator interface {
    TriggerStep(ctx context.Context, stepName string, data map[string]interface{}) error
    OnStepComplete(step WorkflowStep, data map[string]interface{})
    OnStepFailed(step WorkflowStep, err error)
    RegisterStep(step WorkflowStep)
}

// BaseStep menyediakan implementasi default untuk SetCoordinator.
type BaseStep struct {
    coordinator WorkflowCoordinator
}

func (s *BaseStep) SetCoordinator(c WorkflowCoordinator) { s.coordinator = c }

// OrderFulfillmentCoordinator mengorkestrasikan proses fulfillment pesanan.
// Setiap step hanya perlu tahu coordinator, tidak tahu step lain.
type OrderFulfillmentCoordinator struct {
    steps  map[string]WorkflowStep
    logger *slog.Logger

    // Transisi yang dikontrol mediator: ketika step A selesai, jalankan step B
    transitions map[string][]string
}

func NewOrderFulfillmentCoordinator(logger *slog.Logger) *OrderFulfillmentCoordinator {
    c := &OrderFulfillmentCoordinator{
        steps:  make(map[string]WorkflowStep),
        logger: logger,
        transitions: map[string][]string{
            "validate_order":    {"reserve_inventory"},
            "reserve_inventory": {"process_payment"},
            "process_payment":   {"send_confirmation", "update_analytics"},
            "send_confirmation": {}, // terminal — tidak ada step berikutnya
            "update_analytics":  {}, // terminal
        },
    }
    return c
}

// RegisterStep mendaftarkan step ke coordinator.
func (c *OrderFulfillmentCoordinator) RegisterStep(step WorkflowStep) {
    step.SetCoordinator(c)
    c.steps[step.StepName()] = step
}

// TriggerStep menjalankan step tertentu.
func (c *OrderFulfillmentCoordinator) TriggerStep(ctx context.Context, stepName string, data map[string]interface{}) error {
    step, ok := c.steps[stepName]
    if !ok {
        return fmt.Errorf("step %q tidak terdaftar", stepName)
    }

    c.logger.InfoContext(ctx, "executing step", "step", stepName)
    if err := step.Execute(ctx, data); err != nil {
        c.OnStepFailed(step, err)
        return err
    }

    return nil
}

// OnStepComplete dipanggil setelah sebuah step berhasil.
// Koordinator menentukan step mana yang harus dijalankan selanjutnya.
func (c *OrderFulfillmentCoordinator) OnStepComplete(step WorkflowStep, data map[string]interface{}) {
    nextSteps, ok := c.transitions[step.StepName()]
    if !ok || len(nextSteps) == 0 {
        c.logger.Info("workflow branch complete", "last_step", step.StepName())
        return
    }

    ctx := context.Background()
    for _, nextStep := range nextSteps {
        c.logger.InfoContext(ctx, "triggering next step",
            "from", step.StepName(), "to", nextStep)
        if err := c.TriggerStep(ctx, nextStep, data); err != nil {
            c.logger.ErrorContext(ctx, "step failed in chain",
                "step", nextStep, "error", err)
        }
    }
}

// OnStepFailed dipanggil ketika sebuah step gagal.
func (c *OrderFulfillmentCoordinator) OnStepFailed(step WorkflowStep, err error) {
    c.logger.Error("step failed",
        "step", step.StepName(),
        "error", err,
    )
    // Coordinator bisa menentukan: retry? rollback? alarm?
}

// Start memulai workflow dari step pertama.
func (c *OrderFulfillmentCoordinator) Start(ctx context.Context, data map[string]interface{}) error {
    return c.TriggerStep(ctx, "validate_order", data)
}


// Concrete Steps — masing-masing tidak tahu tentang step lain

type ValidateOrderStep struct {
    BaseStep
}

func (s *ValidateOrderStep) StepName() string { return "validate_order" }

func (s *ValidateOrderStep) Execute(ctx context.Context, data map[string]interface{}) error {
    orderID, ok := data["order_id"].(string)
    if !ok || orderID == "" {
        return fmt.Errorf("order_id is required")
    }
    fmt.Printf("[ValidateOrder] Validating order: %s\n", orderID)
    // ... validasi ...
    s.coordinator.OnStepComplete(s, data) // beritahu coordinator bahwa selesai
    return nil
}

type ReserveInventoryStep struct {
    BaseStep
    inventorySvc InventoryService
}

func (s *ReserveInventoryStep) StepName() string { return "reserve_inventory" }

func (s *ReserveInventoryStep) Execute(ctx context.Context, data map[string]interface{}) error {
    fmt.Printf("[ReserveInventory] Reserving stock for order: %s\n", data["order_id"])
    reservationID, err := s.inventorySvc.Reserve(ctx, data["items"])
    if err != nil {
        return fmt.Errorf("reservation failed: %w", err)
    }
    data["reservation_id"] = reservationID
    s.coordinator.OnStepComplete(s, data)
    return nil
}

func (s *ReserveInventoryStep) SetCoordinator(c WorkflowCoordinator) { s.coordinator = c }

// ... step lainnya mengikuti pola yang sama

// Perakitan
func SetupFulfillmentWorkflow(logger *slog.Logger, inventorySvc InventoryService) *OrderFulfillmentCoordinator {
    coord := NewOrderFulfillmentCoordinator(logger)
    coord.RegisterStep(&ValidateOrderStep{})
    coord.RegisterStep(&ReserveInventoryStep{inventorySvc: inventorySvc})
    // ... daftarkan step lainnya
    return coord
}

package mediator

import (
    "fmt"
    "sync"
)

// Event adalah interface yang diimplementasikan semua event.
type Event interface {
    EventName() string
}

// Handler adalah fungsi yang menangani event tertentu.
type Handler[T Event] func(event T) error

// TypedMediator adalah mediator dengan type-safe event handling.
type TypedMediator struct {
    mu       sync.RWMutex
    handlers map[string][]interface{} // map[eventName][]handlerFunc
}

func NewTypedMediator() *TypedMediator {
    return &TypedMediator{
        handlers: make(map[string][]interface{}),
    }
}

// Subscribe mendaftarkan handler untuk event tertentu.
func Subscribe[T Event](m *TypedMediator, handler Handler[T]) {
    var zero T
    eventName := zero.EventName()
    m.mu.Lock()
    defer m.mu.Unlock()
    m.handlers[eventName] = append(m.handlers[eventName], handler)
}

// Publish mengirimkan event ke semua handler yang terdaftar.
func Publish[T Event](m *TypedMediator, event T) []error {
    m.mu.RLock()
    handlers := m.handlers[event.EventName()]
    m.mu.RUnlock()

    var errs []error
    for _, h := range handlers {
        if typedHandler, ok := h.(Handler[T]); ok {
            if err := typedHandler(event); err != nil {
                errs = append(errs, err)
            }
        }
    }
    return errs
}

// Contoh penggunaan typed mediator
type UserRegisteredEvent struct {
    UserID   string
    Email    string
    Username string
}
func (e UserRegisteredEvent) EventName() string { return "user.registered" }

type OrderCreatedEvent struct {
    OrderID string
    UserID  string
    Amount  float64
}
func (e OrderCreatedEvent) EventName() string { return "order.created" }

func setupMediator() {
    m := NewTypedMediator()

    // Type-safe: handler menerima UserRegisteredEvent, bukan interface{}
    Subscribe(m, func(event UserRegisteredEvent) error {
        fmt.Printf("Sending welcome email to %s\n", event.Email)
        return nil
    })

    Subscribe(m, func(event UserRegisteredEvent) error {
        fmt.Printf("Setting up user profile for %s\n", event.Username)
        return nil
    })

    Subscribe(m, func(event OrderCreatedEvent) error {
        fmt.Printf("Processing order %s worth Rp %.0f\n", event.OrderID, event.Amount)
        return nil
    })

    // Publish — type-safe, tidak perlu type assertion di handler
    errs := Publish(m, UserRegisteredEvent{
        UserID: "user-1", Email: "[email protected]", Username: "alice",
    })
    for _, err := range errs {
        fmt.Printf("Handler error: %v\n", err)
    }
}

// ANTI-PATTERN: Mediator yang mengerjakan bisnis logic
func (m *OrderMediator) Notify(sender Colleague, event string, data interface{}) {
    switch event {
    case "stock_updated":
        // Mediator langsung hitung harga — ini bisnis logic!
        if qty, ok := data.(int); ok && qty < 10 {
            newPrice := m.currentPrice * 1.2 // markup 20% kalau stok sedikit
            m.priceComp.SetPrice(newPrice)
        }
        // ...
    case "order_paid":
        // Mediator langsung update analytics — juga bukan tugasnya!
        m.analyticsDB.Insert("purchases", data)
    }
}

// BENAR: Mediator hanya mengatur routing, logika di komponen
func (m *OrderMediator) Notify(sender Colleague, event string, data interface{}) {
    switch event {
    case "stock_updated":
        // Mediator hanya routing — "beritahu price component tentang stock update"
        m.priceComp.OnStockUpdated(data)
    case "order_paid":
        // Mediator hanya routing — tidak tahu apa yang dilakukan analytics
        m.analyticsComp.OnOrderPaid(data)
    }
    // Logika ada di masing-masing komponen, bukan di mediator
}

// MockColleague untuk testing mediator
type MockColleague struct {
    name           string
    mediator       Mediator
    receivedEvents []struct {
        event string
        data  interface{}
    }
}

func (m *MockColleague) ComponentName() string { return m.name }

func (m *MockColleague) SetMediator(med Mediator) { m.mediator = med }

func (m *MockColleague) Notify(event string, data interface{}) {
    m.mediator.Notify(m, event, data)
}

func (m *MockColleague) OnNotified(event string, data interface{}) {
    m.receivedEvents = append(m.receivedEvents, struct {
        event string
        data  interface{}
    }{event, data})
}

func (m *MockColleague) EventCount() int { return len(m.receivedEvents) }


func TestChatRoom_BroadcastToAllExceptSender(t *testing.T) {
    room := chat.NewChatRoom()
    alice := chat.NewUser("Alice")
    bob   := chat.NewUser("Bob")
    citra := chat.NewUser("Citra")

    alice.SetMediator(room)
    bob.SetMediator(room)
    citra.SetMediator(room)

    alice.Send("Hello everyone!")

    // Bob dan Citra harus terima, Alice tidak
    if len(bob.Inbox()) != 1 {
        t.Errorf("Bob should receive 1 message, got %d", len(bob.Inbox()))
    }
    if len(citra.Inbox()) != 1 {
        t.Errorf("Citra should receive 1 message, got %d", len(citra.Inbox()))
    }
    if len(alice.Inbox()) != 0 {
        t.Errorf("Alice should NOT receive her own message")
    }
}

func TestChatRoom_PrivateMessage_OnlyToRecipient(t *testing.T) {
    room := chat.NewChatRoom()
    alice := chat.NewUser("Alice")
    bob   := chat.NewUser("Bob")
    citra := chat.NewUser("Citra")

    alice.SetMediator(room)
    bob.SetMediator(room)
    citra.SetMediator(room)

    err := alice.SendTo("Bob", "Private message for Bob only")
    if err != nil {
        t.Fatalf("unexpected error: %v", err)
    }

    if len(bob.Inbox()) != 1 {
        t.Errorf("Bob should receive private message, got %d", len(bob.Inbox()))
    }
    if !bob.Inbox()[0].IsPrivate {
        t.Error("message should be marked as private")
    }
    if len(citra.Inbox()) != 0 {
        t.Error("Citra should NOT receive private message between Alice and Bob")
    }
}

func TestChatRoom_UnknownRecipient_ReturnsError(t *testing.T) {
    room := chat.NewChatRoom()
    alice := chat.NewUser("Alice")
    alice.SetMediator(room)

    err := alice.SendTo("NonExistentUser", "test")
    if err == nil {
        t.Error("expected error for unknown recipient")
    }
}

func TestChatRoom_Unregister_StopsMessages(t *testing.T) {
    room := chat.NewChatRoom()
    alice := chat.NewUser("Alice")
    bob   := chat.NewUser("Bob")

    alice.SetMediator(room)
    bob.SetMediator(room)

    room.Unregister("Bob")
    alice.Send("Hello Bob!")

    // Bob sudah keluar, tidak terima pesan baru
    if len(bob.Inbox()) != 0 {
        t.Errorf("Bob should not receive message after unregistering")
    }
}