package checkout
import (
"context"
"fmt"
"time"
)
// CheckoutService orchestrates the full checkout flow.
type CheckoutService struct {
inventoryClient *InventoryClient
orderClient *OrderClient
paymentClient *PaymentClient
outboxWriter *OutboxWriter
logger *slog.Logger
metrics MetricsRecorder
}
// NewCheckoutService creates the checkout service.
func NewCheckoutService(
inventory *InventoryClient,
order *OrderClient,
payment *PaymentClient,
outbox *OutboxWriter,
logger *slog.Logger,
metrics MetricsRecorder,
) *CheckoutService {
return &CheckoutService{
inventoryClient: inventory,
orderClient: order,
paymentClient: payment,
outboxWriter: outbox,
logger: logger,
metrics: metrics,
}
}
// Checkout initiates the checkout saga.
func (cs *CheckoutService) Checkout(ctx context.Context, req CheckoutRequest) (*SagaResult, error) {
if err := req.Validate(); err != nil {
return nil, fmt.Errorf("checkout: invalid request: %w", err)
}
// Generate order ID and idempotency key
orderID := generateOrderID()
idempotencyKey := fmt.Sprintf("checkout:%s:%d", orderID, time.Now().Unix())
sagaCtx := SagaContext{
OrderID: orderID,
UserID: req.UserID,
Items: req.Items,
Amount: calculateTotal(req.Items),
PaymentMethod: req.PaymentMethod,
IdempotencyKey: idempotencyKey,
}
steps := []SagaStep{
{
Name: "reserve_stock",
Execute: func(ctx context.Context, sc SagaContext) error {
resp, err := cs.inventoryClient.ReserveStock(ctx, sc.OrderID, sc.Items)
if err != nil {
return fmt.Errorf("reserve stock: %w", err)
}
sc.ReservationID = resp.ReservationID
return nil
},
Compensate: func(ctx context.Context, sc SagaContext) error {
return cs.inventoryClient.ReleaseStock(ctx, sc.OrderID, sc.Items)
},
},
{
Name: "create_order_pending",
Execute: func(ctx context.Context, sc SagaContext) error {
return cs.orderClient.CreateOrder(ctx, sc.OrderID, sc.UserID, sc.Items, OrderStatusPending)
},
Compensate: func(ctx context.Context, sc SagaContext) error {
return cs.orderClient.CancelOrder(ctx, sc.OrderID, "payment_failed")
},
},
{
Name: "charge_payment",
Execute: func(ctx context.Context, sc SagaContext) error {
resp, err := cs.paymentClient.Charge(ctx, PaymentRequest{
IdempotencyKey: sc.IdempotencyKey,
Amount: sc.Amount,
Currency: "IDR",
PaymentMethod: sc.PaymentMethod,
OrderID: sc.OrderID,
})
if err != nil {
return fmt.Errorf("charge payment: %w", err)
}
sc.PaymentTxID = resp.TransactionID
return nil
},
Compensate: func(ctx context.Context, sc SagaContext) error {
if sc.PaymentTxID != "" {
return cs.paymentClient.Refund(ctx, sc.PaymentTxID, sc.Amount)
}
return nil
},
},
{
Name: "confirm_order",
Execute: func(ctx context.Context, sc SagaContext) error {
return cs.orderClient.ConfirmOrder(ctx, sc.OrderID, sc.PaymentTxID)
},
Compensate: func(ctx context.Context, sc SagaContext) error {
return cs.orderClient.CancelOrder(ctx, sc.OrderID, "compensation_after_confirm")
},
},
{
Name: "publish_events",
Execute: func(ctx context.Context, sc SagaContext) error {
events := []OutboxEvent{
{
AggregateType: "order",
AggregateID: sc.OrderID,
EventType: "order.confirmed",
Payload: marshalJSON(OrderConfirmedEvent{OrderID: sc.OrderID, Amount: sc.Amount}),
},
{
AggregateType: "payment",
AggregateID: sc.OrderID,
EventType: "payment.success",
Payload: marshalJSON(PaymentSuccessEvent{OrderID: sc.OrderID, TxID: sc.PaymentTxID}),
},
{
AggregateType: "dispatch",
AggregateID: sc.OrderID,
EventType: "dispatch.requested",
Payload: marshalJSON(DispatchRequestedEvent{OrderID: sc.OrderID, Items: sc.Items}),
},
}
return cs.outboxWriter.WriteBatch(ctx, events)
},
Compensate: nil, // Events cannot be unpublished; downstream handles dedup
},
}
orchestrator := NewSagaOrchestrator(steps, cs.logger, cs.metrics)
result := orchestrator.Execute(ctx, sagaCtx)
return result, nil
}
// CheckoutRequest is the API input.
type CheckoutRequest struct {
UserID string `json:"user_id"`
Items []OrderItem `json:"items"`
PaymentMethod string `json:"payment_method"`
}
func (r CheckoutRequest) Validate() error {
if r.UserID == "" {
return fmt.Errorf("user_id required")
}
if len(r.Items) == 0 {
return fmt.Errorf("at least one item required")
}
if r.PaymentMethod == "" {
return fmt.Errorf("payment_method required")
}
return nil
}
func calculateTotal(items []OrderItem) int64 {
var total int64
for _, item := range items {
total += item.PriceCents * int64(item.Quantity)
}
return total
}
func generateOrderID() string {
return fmt.Sprintf("ORD-%d", time.Now().UnixNano())
}
// Order status constants.
type OrderStatus string
const (
OrderStatusPending OrderStatus = "PENDING"
OrderStatusConfirmed OrderStatus = "CONFIRMED"
OrderStatusCancelled OrderStatus = "CANCELLED"
)
