PHP Patterns & Practice

interface UserRepository
{
    public function find(int $id): ?User;
}

final class UserChecker
{
    public function __construct(private UserRepository $users) {}

    public function isEnabled(int $id): bool
    {
        return $this->users->find($id)?->isEnabled() ?? false;
    }
}

$checker = new UserChecker($repository);

interface Exporter
{
    public function export(array $rows): string;
}

final class Exporters
{
    public static function for(string $format): Exporter
    {
        return match ($format) {
            'json' => new JsonExporter(),
            'csv' => new CsvExporter(),
            default => throw new InvalidArgumentException(
                "Unknown format: $format"
            ),
        };
    }
}

$exporter = Exporters::for('json');

interface Book
{
    public function open(): void;
    public function nextPage(): int;
}

final class KindleAdapter implements Book
{
    public function __construct(private Kindle $kindle) {}

    public function open(): void
    {
        $this->kindle->unlock();
    }

    public function nextPage(): int
    {
        $this->kindle->pressNext();
        return $this->kindle->currentPage();
    }
}

interface Booking
{
    public function price(): int;
}

final class Room implements Booking
{
    public function price(): int { return 80; }
}

final class Breakfast implements Booking
{
    public function __construct(private Booking $booking) {}
    public function price(): int { return $this->booking->price() + 15; }
}

$booking = new Breakfast(new Room()); // 95

interface Listener
{
    public function handle(UserRegistered $event): void;
}

final class RegistrationPublisher
{
    /** @param list<Listener> $listeners */
    public function __construct(private array $listeners) {}

    public function publish(UserRegistered $event): void
    {
        foreach ($this->listeners as $listener) {
            $listener->handle($event);
        }
    }
}

interface Check
{
    public function handle(Request $request, Closure $next): Response;
}

final class RequireVerifiedUser implements Check
{
    public function handle(Request $request, Closure $next): Response
    {
        if (! $request->user?->isVerified()) {
            return new Response(403);
        }

        return $next($request);
    }
}

// Pipeline: Authenticate → RequireVerifiedUser → controller

interface Specification
{
    public function isSatisfiedBy(Product $product): bool;
}

final class InStock implements Specification
{
    public function isSatisfiedBy(Product $product): bool
    {
        return $product->stockCount() > 0;
    }
}

$available = (new InStock())->isSatisfiedBy($product);

interface ShippingCost
{
    public function calculate(Order $order): int;
}

final class StandardShipping implements ShippingCost
{
    public function calculate(Order $order): int { return 500; }
}

final class Checkout
{
    public function __construct(private ShippingCost $shipping) {}

    public function total(Order $order): int
    {
        return $order->subtotal() + $this->shipping->calculate($order);
    }
}

$checkout = new Checkout(new StandardShipping());

interface Notification
{
    public function send(string $message): void;
}

abstract class Notifier
{
    abstract protected function makeNotification(): Notification;

    public function notify(string $message): void
    {
        $this->makeNotification()->send($message);
    }
}

final class EmailNotifier extends Notifier
{
    protected function makeNotification(): Notification
    {
        return new EmailNotification();
    }
}

final readonly class ReportQuery
{
    public function __construct(
        public array $filters,
        public ?string $sort,
    ) {}
}

final class ReportQueryBuilder
{
    private array $filters = [];
    private ?string $sort = null;

    public function where(string $field, string $value): self
    {
        $this->filters[$field] = $value;
        return $this;
    }

    public function sortBy(string $field): self
    {
        $this->sort = $field;
        return $this;
    }

    public function build(): ReportQuery
    {
        return new ReportQuery($this->filters, $this->sort);
    }
}

$query = (new ReportQueryBuilder())
    ->where('status', 'open')
    ->sortBy('created_at')
    ->build();

final readonly class SendInvoice
{
    public function __construct(public int $invoiceId) {}
}

interface InvoiceRepository
{
    public function find(int $id): Invoice;
}

final class SendInvoiceHandler
{
    public function __construct(
        private InvoiceRepository $invoices,
        private Mailer $mailer,
    ) {}

    public function handle(SendInvoice $command): void
    {
        $invoice = $this->invoices->find($command->invoiceId);
        $this->mailer->send($invoice->email());
    }
}

$commandBus->dispatch(new SendInvoice($invoiceId));

interface OrderRepository
{
    public function find(OrderId $id): ?Order;
    public function save(Order $order): void;
}

final class PlaceOrder
{
    public function __construct(private OrderRepository $orders) {}

    public function handle(Order $order): void
    {
        $order->place();
        $this->orders->save($order);
    }
}