PHP 8.5 `clone with` : Value Objects immutables sans boilerplate DDD

<?php
// PHP 8.2-8.4 : trois stratégies, toutes douloureuses

// 1. Rappeler le constructeur complet (fragile si signature évolue)
readonly class Money
{
    public function __construct(
        public readonly int $amountInCents,
        public readonly string $currency,
        public readonly int $scale,
    ) {}

    public function withAmount(int $amount): self
    {
        return new self($amount, $this->currency, $this->scale); // si on ajoute une prop, on oublie ici
    }
}

// 2. Passer par ReflectionClass (lent, illisible, aucun type safety)
public function cloneWithAmount(int $amount): self
{
    $clone = (new ReflectionClass($this))->newInstanceWithoutConstructor();
    $ref = new ReflectionProperty($this, 'amountInCents');
    $ref->setValue($clone, $amount);
    // ... répéter pour chaque prop copiée
    return $clone;
}

// 3. Wither methods manuelles (maintenable mais O(N) par propriété)
public function withCurrency(string $currency): self
{
    return new self($this->amountInCents, $currency, $this->scale);
}
public function withScale(int $scale): self
{
    return new self($this->amountInCents, $this->currency, $scale);
}

<?php
// PHP 8.5+

readonly class Money
{
    public function __construct(
        public readonly int $amountInCents,
        public readonly string $currency,
        public readonly int $scale = 2,
    ) {}
}

$price = new Money(1000, 'EUR');

// Changer une seule propriété readonly — sans wither method
$discounted = clone $price with ['amountInCents' => 800];

var_dump($discounted->amountInCents); // int(800)
var_dump($discounted->currency);     // string(3) "EUR"
var_dump($discounted->scale);        // int(2)

// Changer plusieurs propriétés en une passe
$converted = clone $price with [
    'amountInCents' => 1080,
    'currency' => 'USD',
];

<?php
// Avant PHP 8.5 : 5 wither methods = 30+ lignes de boilerplate

readonly class Address
{
    public function __construct(
        public readonly string $street,
        public readonly string $city,
        public readonly string $postalCode,
        public readonly string $countryCode,
        public readonly string|null $complement = null,
    ) {}

    public function withStreet(string $street): self
    {
        return new self($street, $this->city, $this->postalCode, $this->countryCode, $this->complement);
    }

    public function withCity(string $city): self
    {
        return new self($this->street, $city, $this->postalCode, $this->countryCode, $this->complement);
    }

    public function withPostalCode(string $postalCode): self
    {
        return new self($this->street, $this->city, $postalCode, $this->countryCode, $this->complement);
    }

    // ... et ainsi de suite
}

// Après PHP 8.5 : 0 wither method
$updated = clone $address with ['street' => '12 rue de la Paix', 'postalCode' => '75001'];

<?php
declare(strict_types=1);

namespace App\Domain\Shared\ValueObject;

use InvalidArgumentException;

readonly class Money
{
    public function __construct(
        public readonly int $amountInCents,
        public readonly string $currency,
    ) {
        if ($amountInCents < 0) {
            throw new InvalidArgumentException('Amount cannot be negative.');
        }
        if (!in_array($currency, ['EUR', 'USD', 'GBP'], strict: true)) {
            throw new InvalidArgumentException("Unsupported currency: $currency");
        }
    }

    public function add(self $other): self
    {
        if ($this->currency !== $other->currency) {
            throw new InvalidArgumentException('Cannot add different currencies.');
        }
        // clone with contourne le constructeur — on vérifie manuellement
        assert($this->amountInCents + $other->amountInCents >= 0);
        return clone $this with ['amountInCents' => $this->amountInCents + $other->amountInCents];
    }

    public function applyDiscount(float $rate): self
    {
        return clone $this with [
            'amountInCents' => (int) round($this->amountInCents * (1 - $rate)),
        ];
    }
}

readonly class EmailAddress
{
    public function __construct(public readonly string $value)
    {
        if (!filter_var($value, FILTER_VALIDATE_EMAIL)) {
            throw new InvalidArgumentException("Invalid email: $value");
        }
    }
}

readonly class DateRange
{
    public function __construct(
        public readonly \DateTimeImmutable $start,
        public readonly \DateTimeImmutable $end,
    ) {
        if ($end <= $start) {
            throw new InvalidArgumentException('End must be after start.');
        }
    }

    public function extendBy(\DateInterval $interval): self
    {
        return clone $this with ['end' => $this->end->add($interval)];
    }
}

<?php
declare(strict_types=1);

namespace App\Domain\Order;

use App\Domain\Shared\ValueObject\Money;

class Order
{
    private function __construct(
        public readonly OrderId $id,
        private readonly array $lines, // OrderLine[]
        private readonly Money $total,
        private readonly OrderStatus $status,
    ) {}

    public static function create(OrderId $id, OrderLine ...$lines): self
    {
        $total = array_reduce(
            $lines,
            fn (Money $carry, OrderLine $line) => $carry->add($line->subtotal()),
            new Money(0, 'EUR'),
        );

        return new self($id, $lines, $total, OrderStatus::Draft);
    }

    public function confirm(): self
    {
        if ($this->status !== OrderStatus::Draft) {
            throw new \DomainException('Only draft orders can be confirmed.');
        }

        // On retourne une nouvelle instance de l'Aggregate
        // sans toucher aux autres champs
        return clone $this with ['status' => OrderStatus::Confirmed];
    }

    public function applyGlobalDiscount(float $rate): self
    {
        return clone $this with [
            'total' => $this->total->applyDiscount($rate),
            'lines' => array_map(
                fn (OrderLine $l) => $l->withDiscount($rate),
                $this->lines,
            ),
        ];
    }
}

// Usage dans un Command Handler Symfony
final class ConfirmOrderHandler
{
    public function __construct(
        private readonly OrderRepository $orders,
    ) {}

    public function __invoke(ConfirmOrderCommand $command): void
    {
        $order = $this->orders->get($command->orderId);
        $confirmed = $order->confirm();
        $this->orders->save($confirmed);
    }
}

<?php
// PHPUnit 11 + Pest — tests sur Money avec clone with
it('applies a 20% discount correctly', function (): void {
    $price = new Money(1000, 'EUR');
    $discounted = $price->applyDiscount(0.20);

    expect($discounted->amountInCents)->toBe(800);
    expect($discounted->currency)->toBe('EUR');

    // L'original reste intact — immutabilité garantie par readonly
    expect($price->amountInCents)->toBe(1000);
});

it('preserves currency on addition', function (): void {
    $a = new Money(300, 'EUR');
    $b = new Money(700, 'EUR');

    expect($a->add($b)->amountInCents)->toBe(1000);
    expect($a->amountInCents)->toBe(300); // $a inchangé
});

it('rejects cross-currency addition', function (): void {
    expect(fn () => new Money(500, 'EUR')->add(new Money(200, 'USD')))
        ->toThrow(InvalidArgumentException::class, 'Cannot add different currencies.');
});