Composition Root

<?php

//entity
class Order {
    function __construct(
        public readonly int $id,
        public readonly int $total
    ) {}

    function payable(): int {
        return $this->total >= 200
            ? $this->total - intdiv($this->total, 10)
            : $this->total;
    }
}

//gateway
interface Catalog {
    function price(string $sku): ?int;
}

//repository
interface Orders {
    function save(Order $order): void;

    function count(): int;
}

//output port
interface Report {
    function say(string $text): void;
}

//use case: asks for its parts, never builds them
class PlaceOrder {
    private int $nextId = 1001;

    function __construct(
        private Catalog $catalog,
        private Orders $orders,
        private Report $report
    ) {}

    function place(array $items): void {
        $total = 0;
        foreach ($items as $sku => $count) {
            $price = $this->catalog->price($sku);
            if ($price === null) {
                $this->report->say("no " . $sku);
                return;
            }
            $total += $price * $count;
        }
        $order = new Order($this->nextId++, $total);
        $this->orders->save($order);
        $this->report->say("order " . $order->id
            . " for " . $order->payable());
    }
}

//adapters
class MemoryCatalog implements Catalog {
    function price(string $sku): ?int {
        return ["pen" => 30, "lamp" => 190][$sku] ?? null;
    }
}

class MemoryOrders implements Orders {
    private array $rows = [];

    function save(Order $order): void {
        $this->rows[] = $order;
    }

    function count(): int {
        return count($this->rows);
    }
}

class ConsoleReport implements Report {
    function say(string $text): void {
        echo $text, "\n";
    }
}

class SilentReport implements Report {
    function say(string $text): void {
    }
}

//composition root: the only place that sees every layer
//at once, and the only place where an adapter is built
final class ShopApp {
    public readonly PlaceOrder $useCase;

    function __construct(
        Catalog $catalog,
        public readonly Orders $orders,
        Report $report
    ) {
        $this->useCase =
            new PlaceOrder($catalog, $orders, $report);
    }

    //named arguments: wiring reads as a list of parts
    static function loud(): self {
        return new self(
            catalog: new MemoryCatalog(),
            orders: new MemoryOrders(),
            report: new ConsoleReport());
    }

    static function quiet(): self {
        return new self(
            catalog: new MemoryCatalog(),
            orders: new MemoryOrders(),
            report: new SilentReport());
    }
}

//client code
$app = ShopApp::loud();
$app->useCase->place(["pen" => 2, "lamp" => 1]);
$app->useCase->place(["chair" => 1]);

//a second root builds the same use case differently
$night = ShopApp::quiet();
$night->useCase->place(["lamp" => 1]);
echo "saved ", $night->orders->count(), "\n";
//printed: order 1001 for 225
//         no chair
//         saved 1