How do you implement the Saga pattern for distributed transactions in Go?

// Choreography-based saga: services react to events

// OrderService publishes OrderCreated
type OrderCreatedEvent struct {
    OrderID   string  `json:"order_id"`
    UserID    string  `json:"user_id"`
    Amount    float64 `json:"amount"`
    ProductID string  `json:"product_id"`
}

// PaymentService consumes OrderCreated, publishes PaymentProcessed or PaymentFailed
func (s *PaymentService) HandleOrderCreated(ctx context.Context,
    event OrderCreatedEvent) error {

    charged, err := s.stripe.Charge(ctx, event.UserID, event.Amount)
    if err != nil {
        // Publish compensating event for OrderService to cancel the order
        return s.publisher.Publish(ctx, PaymentFailedEvent{
            OrderID: event.OrderID,
            Reason:  err.Error(),
        })
    }
    return s.publisher.Publish(ctx, PaymentProcessedEvent{
        OrderID:   event.OrderID,
        ChargeID:  charged.ID,
    })
}

// InventoryService consumes PaymentProcessed, publishes StockReserved or StockUnavailable
// OrderService listens to StockReserved → fulfillment
// OrderService listens to StockUnavailable → refund (another compensating event)

// Outbox pattern: ensure event is published atomically with DB write
func (s *OrderService) CreateOrder(ctx context.Context, req OrderRequest) error {
    tx, err := s.db.BeginTx(ctx, nil)
    if err != nil { return err }
    defer tx.Rollback()

    // Write order to DB
    orderID := uuid.New().String()
    tx.ExecContext(ctx, "INSERT INTO orders ...", orderID, req.UserID)

    // Write event to outbox table in SAME transaction
    eventData, _ := json.Marshal(OrderCreatedEvent{OrderID: orderID})
    tx.ExecContext(ctx,
        "INSERT INTO outbox (event_type, payload) VALUES ($1, $2)",
        "order.created", eventData)

    return tx.Commit()
    // Separate process reads outbox and publishes to message queue
}