Clean Architecture in Laravel: Practical Patterns for Real Projects

class OrderController extends Controller
{
    public function store(Request $request)
    {
        $validated = $request->validate([
            'items' => 'required|array',
            'shipping_address_id' => 'required|exists:addresses,id',
        ]);

        $order = Order::create([
            'user_id' => auth()->id(),
            'status' => 'pending',
        ]);

        foreach ($validated['items'] as $item) {
            $product = Product::find($item['product_id']);
            $order->items()->create([
                'product_id' => $product->id,
                'quantity' => $item['quantity'],
                'price' => $product->price,
            ]);

            $product->decrement('stock', $item['quantity']);
        }

        // Send notification
        Mail::to($order->user)->send(new OrderConfirmation($order));

        return redirect()->route('orders.show', $order);
    }
}

app/
├── Domain/           # Business logic, no framework dependencies
│   ├── Orders/
│   │   ├── Order.php
│   │   ├── OrderItem.php
│   │   └── OrderService.php
│   └── Products/
├── Application/      # Use cases, orchestration
│   └── Orders/
│       └── CreateOrderAction.php
├── Infrastructure/   # Framework, database, external services
│   ├── Persistence/
│   └── Mail/
└── Http/             # Controllers, requests, resources
    └── Controllers/

// Domain/Orders/Order.php
class Order
{
    private array $items = [];
    private OrderStatus $status;

    public function __construct(
        private string $id,
        private string $customerId
    ) {
        $this->status = OrderStatus::Pending;
    }

    public function addItem(Product $product, int $quantity): void
    {
        if ($quantity <= 0) {
            throw new InvalidQuantityException();
        }

        if ($product->stockCount() < $quantity) {
            throw new InsufficientStockException($product);
        }

        $this->items[] = new OrderItem(
            product: $product,
            quantity: $quantity,
            priceAtPurchase: $product->price()
        );
    }

    public function total(): Money
    {
        return array_reduce(
            $this->items,
            fn (Money $sum, OrderItem $item) => $sum->add($item->subtotal()),
            Money::zero()
        );
    }
}

// Application/Orders/CreateOrderAction.php
class CreateOrderAction
{
    public function __construct(
        private OrderRepository $orders,
        private ProductRepository $products,
        private EventDispatcher $events
    ) {}

    public function execute(CreateOrderDto $dto): Order
    {
        $order = new Order(
            id: Uuid::generate(),
            customerId: $dto->customerId
        );

        foreach ($dto->items as $itemDto) {
            $product = $this->products->findOrFail($itemDto->productId);
            $order->addItem($product, $itemDto->quantity);
        }

        $this->orders->save($order);

        $this->events->dispatch(new OrderCreated($order));

        return $order;
    }
}

// Infrastructure/Persistence/EloquentOrderRepository.php
class EloquentOrderRepository implements OrderRepository
{
    public function save(Order $order): void
    {
        $model = OrderModel::updateOrCreate(
            ['id' => $order->id()],
            [
                'customer_id' => $order->customerId(),
                'status' => $order->status()->value,
                'total' => $order->total()->amount(),
            ]
        );

        // Save items...
    }

    public function findOrFail(string $id): Order
    {
        $model = OrderModel::with('items.product')->findOrFail($id);
        return $this->toDomain($model);
    }
}

class OrderController extends Controller
{
    public function store(
        CreateOrderRequest $request,
        CreateOrderAction $action
    ) {
        $order = $action->execute(
            CreateOrderDto::fromRequest($request)
        );

        return redirect()->route('orders.show', $order->id());
    }
}