class OrderRepository:
    def save(self, order):
        with self.db.transaction():  # Transaction per operation
            self.db.insert('orders', order)

class InventoryRepository:
    def reserve(self, items):
        with self.db.transaction():  # Separate transaction
            for item in items:
                self.db.update('inventory', item.sku, decrement=item.qty)

class PlaceOrderUseCase:
    def execute(self, command):
        order = Order.create(command.items)
        self.orders.save(order)  # Commits
        self.inventory.reserve(command.items)  # If this fails, order is orphaned!
        self.payments.charge(order.total)  # If this fails, inventory is reserved but unpaid

# application/ports/UnitOfWork.py
class UnitOfWork(Protocol):
    def begin(self) -> None: ...
    def commit(self) -> None: ...
    def rollback(self) -> None: ...

# application/usecases/PlaceOrderUseCase.py
class PlaceOrderUseCase:
    def __init__(self, uow: UnitOfWork, orders, inventory, payments):
        self.uow = uow
        self.orders = orders
        self.inventory = inventory
        self.payments = payments

    def execute(self, command):
        self.uow.begin()
        try:
            order = Order.create(command.items)

            self.inventory.reserve(command.items)
            self.payments.charge(order.total)
            self.orders.save(order)

            self.uow.commit()  # All or nothing
            return order.id

        except Exception as e:
            self.uow.rollback()  # Clean rollback
            raise

# Alternative using context manager
class PlaceOrderUseCase:
    def execute(self, command):
        with self.uow:  # Transaction spans entire use case
            order = Order.create(command.items)
            self.inventory.reserve(command.items)
            self.payments.charge(order.total)
            self.orders.save(order)
            return order.id