Saga Pattern & Distributed Transactions

from enum import Enum
from dataclasses import dataclass, field
from typing import List
import uuid

class SagaState(Enum):
    STARTED = "started"
    ORDER_CREATED = "order_created"
    PAYMENT_CHARGED = "payment_charged"
    INVENTORY_RESERVED = "inventory_reserved"
    COMPLETED = "completed"
    # Compensating states
    COMPENSATING = "compensating"
    COMPENSATED = "compensated"
    FAILED = "failed"

@dataclass
class OrderSaga:
    saga_id: str = field(default_factory=lambda: str(uuid.uuid4()))
    state: SagaState = SagaState.STARTED
    order_id: str = None
    payment_id: str = None
    inventory_reserved: bool = False
    compensations_done: List[str] = field(default_factory=list)

class OrderSagaOrchestrator:
    """Central orchestrator — entire saga flow এবং compensations manage করে"""

    def execute(self, user_id: str, product_id: str, amount: float) -> dict:
        saga = OrderSaga()
        print(f"\n🚀 Starting Saga: {saga.saga_id}")

        # Step 1: Create Order
        try:
            saga.order_id = self._create_order(user_id, product_id, amount)
            saga.state = SagaState.ORDER_CREATED
            print(f"✅ T1: Order created: {saga.order_id}")
        except Exception as e:
            saga.state = SagaState.FAILED
            return {"status": "failed", "reason": f"Order creation failed: {e}"}

        # Step 2: Charge Payment
        try:
            saga.payment_id = self._charge_payment(user_id, amount)
            saga.state = SagaState.PAYMENT_CHARGED
            print(f"✅ T2: Payment charged: {saga.payment_id}")
        except Exception as e:
            print(f"❌ T2 failed: {e} — Compensating T1...")
            self._compensate_order(saga.order_id)
            saga.compensations_done.append("order_cancelled")
            saga.state = SagaState.COMPENSATED
            return {"status": "failed", "reason": "Payment failed", "compensated": True}

        # Step 3: Reserve Inventory
        try:
            self._reserve_inventory(product_id)
            saga.inventory_reserved = True
            saga.state = SagaState.INVENTORY_RESERVED
            print(f"✅ T3: Inventory reserved for {product_id}")
        except Exception as e:
            print(f"❌ T3 failed: {e} — Compensating T2, T1...")
            self._refund_payment(saga.payment_id, amount)     # C2
            self._compensate_order(saga.order_id)             # C1
            saga.compensations_done.extend(["payment_refunded", "order_cancelled"])
            saga.state = SagaState.COMPENSATED
            return {"status": "failed", "reason": "Out of stock",
                    "compensated": True, "refunded": amount}

        saga.state = SagaState.COMPLETED
        print(f"🎉 Saga COMPLETED: order={saga.order_id}")
        return {"status": "success", "order_id": saga.order_id}

    def _create_order(self, user_id, product_id, amount) -> str:
        return f"order_{uuid.uuid4().hex[:8]}"

    def _charge_payment(self, user_id, amount) -> str:
        if amount > 10000: raise Exception("Insufficient funds")
        return f"pay_{uuid.uuid4().hex[:8]}"

    def _reserve_inventory(self, product_id):
        if product_id == "OUT_OF_STOCK": raise Exception("No stock!")

    def _compensate_order(self, order_id):
        print(f"  ↩️ C1: Order {order_id} cancelled")

    def _refund_payment(self, payment_id, amount):
        print(f"  ↩️ C2: Payment {payment_id} refunded ৳{amount}")

# Test
orchestrator = OrderSagaOrchestrator()
print("=== Happy Path ===")
orchestrator.execute("user1", "product1", 500)
print("\n=== Out of Stock ===")
orchestrator.execute("user2", "OUT_OF_STOCK", 500)

const EventEmitter = require('events');
const bus = new EventEmitter(); // In production: Kafka/RabbitMQ

// ===== ORDER SERVICE =====
bus.on('order.start', ({ orderId, userId, productId, amount }) => {
    console.log(`📦 OrderService: Creating order ${orderId}`);
    // Save to DB, then publish next event
    bus.emit('order.created', { orderId, userId, productId, amount });
});

bus.on('order.cancel', ({ orderId, reason }) => {
    console.log(`↩️  OrderService: Cancelling order ${orderId} — ${reason}`);
});

// ===== PAYMENT SERVICE =====
bus.on('order.created', ({ orderId, userId, amount }) => {
    console.log(`💳 PaymentService: Charging ৳${amount} for ${orderId}`);
    try {
        if (amount > 10000) throw new Error('Insufficient funds');
        const paymentId = `pay_${Date.now()}`;
        bus.emit('payment.charged', { orderId, paymentId, amount });
    } catch (err) {
        // Compensation: cancel the order
        bus.emit('order.cancel', { orderId, reason: err.message });
    }
});

bus.on('payment.refund', ({ paymentId, amount }) => {
    console.log(`↩️  PaymentService: Refunding ৳${amount} for ${paymentId}`);
});

// ===== INVENTORY SERVICE =====
bus.on('payment.charged', ({ orderId, paymentId, amount }) => {
    console.log(`📦 InventoryService: Reserving stock for ${orderId}`);
    try {
        if (orderId.includes('nostock')) throw new Error('Out of stock');
        bus.emit('inventory.reserved', { orderId });
    } catch (err) {
        // Compensations: refund + cancel order
        bus.emit('payment.refund', { paymentId, amount });
        bus.emit('order.cancel', { orderId, reason: err.message });
    }
});

bus.on('inventory.reserved', ({ orderId }) => {
    console.log(`🎉 SAGA COMPLETE: Order ${orderId} fulfilled!`);
});

// Test happy path
bus.emit('order.start', { orderId: 'ord-001', userId: 'u1', productId: 'p1', amount: 500 });
// Test failure path
bus.emit('order.start', { orderId: 'nostock-002', userId: 'u2', productId: 'p2', amount: 200 });