Daniel Ortega

export function CancelOrderButton({ orderId }: { orderId: string }) {
  const [cancelOrder, { loading, error }] = useMutation(CANCEL_ORDER, {
    variables: { id: orderId },
    optimisticResponse: {
      cancelOrder: { __typename: "Order", id: orderId, status: "CANCELLED" },
    },
  });

  if (error) return <Alert>{messageFor(error)}</Alert>;

  return (
    <Button onClick={() => cancelOrder()} disabled={loading}>
      Cancelar pedido
    </Button>
  );
}

type Mutation {
  "Falla con ORDER_ALREADY_SHIPPED si el pedido ya ha salido."
  cancelOrder(id: ID!): Order!
}

type Order {
  id: ID!
  status: OrderStatus!
  cancelledAt: DateTime
}

enum OrderStatus {
  PAID
  SHIPPED
  CANCELLED
}

#[AsMessageHandler]
final readonly class CancelOrderHandler
{
    public function __construct(
        private OrderRepository $orders,
        private ClockInterface $clock,
        private EventBus $events,
    ) {}

    public function __invoke(CancelOrder $command): void
    {
        $order = $this->orders->get(new OrderId($command->orderId));

        $order->cancel($this->clock->now());

        $this->orders->save($order);
        $this->events->publish(...$order->releaseEvents());
    }
}

final class Order
{
    use RecordsEvents;

    public function cancel(DateTimeImmutable $now): void
    {
        if ($this->status === OrderStatus::Shipped) {
            throw OrderAlreadyShipped::withId($this->id);
        }

        if ($this->status === OrderStatus::Cancelled) {
            return; // Idempotente: cancelar dos veces no es un error.
        }

        $this->status = OrderStatus::Cancelled;
        $this->cancelledAt = $now;
        $this->record(new OrderCancelled($this->id, $now));
    }
}

// Dominio: el puerto no sabe nada de Doctrine.
interface OrderRepository
{
    public function get(OrderId $id): Order;
    public function save(Order $order): void;
}

// Infraestructura: el adaptador se cambia sin tocar el dominio.
final readonly class DoctrineOrderRepository implements OrderRepository
{
    public function __construct(private EntityManagerInterface $em) {}

    public function get(OrderId $id): Order
    {
        return $this->em->find(Order::class, $id)
            ?? throw OrderNotFound::withId($id);
    }

    public function save(Order $order): void
    {
        $this->em->persist($order);
        $this->em->flush();
    }
}

final class OrderTest extends TestCase
{
    public function test_a_shipped_order_cannot_be_cancelled(): void
    {
        $order = OrderMother::shipped();

        $this->expectException(OrderAlreadyShipped::class);

        $order->cancel(new DateTimeImmutable('2026-01-01'));
    }

    public function test_cancelling_twice_records_one_event(): void
    {
        $order = OrderMother::paid();
        $now = new DateTimeImmutable('2026-01-01');

        $order->cancel($now);
        $order->cancel($now);

        $this->assertCount(1, $order->releaseEvents());
    }
}